Update to v0.4.2

Switch some links in Readme to spike.codes instance
Fix Replit links
2021-03-12 13:48:43 -08:00 · 2021-03-12 12:59:50 -08:00 · 2021-03-12 12:55:02 -08:00 · 2021-03-12 12:21:02 -08:00 · 2021-03-11 20:15:26 -08:00 · 2021-03-10 21:43:06 -08:00
31 changed files with 1513 additions and 3115 deletions
--- a/.github/workflows/docker-build.yml
+++ b/.github/workflows/docker-build.yml
@ -0,0 +1,36 @@
+name: Docker Multi-Architecture Build
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+    branches:
+      - master
+
+jobs:
+  build-docker:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+        with:
+          platforms: all
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v1
+        with:
+          version: latest
+      - name: Login to DockerHub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: spikecodes/libreddit:latest
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@ -11,7 +11,7 @@ env:

 jobs:
  build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-18.04

    steps:
      - uses: actions/checkout@v2
--- a/.gitignore
+++ b/.gitignore
@ -1 +1,2 @@
 /target
+Cargo.lock
--- a/1
+++ b/1
@ -0,0 +1 @@
+*       @spikecodes
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@ -3,19 +3,19 @@ name = "libreddit"
 description = " Alternative private front-end to Reddit"
 license = "AGPL-3.0"
 repository = "https://github.com/spikecodes/libreddit"
-version = "0.2.9"
+version = "0.4.2"
 authors = ["spikecodes <19519553+spikecodes@users.noreply.github.com>"]
 edition = "2018"

 [dependencies]
-base64 = "0.13"
-actix-web = { version = "3.3", features = ["rustls"] }
-futures = "0.3"
-askama = "0.10"
-ureq = "2"
-serde = { version = "1.0", default_features = false, features = ["derive"] }
-serde_json = "1.0"
-async-recursion = "0.3"
-url = "2.2"
-regex = "1.4"
-time = "0.2"
+askama = { version = "0.10.5", default-features = false }
+async-recursion = "0.3.2"
+async-std = { version = "1.9.0", features = ["attributes"] }
+async-tls = { version = "0.11.0", default-features = false, features = ["client"] }
+cached = "0.23.0"
+clap = { version = "2.33.3", default-features = false }
+regex = "1.4.4"
+serde = { version = "1.0.124", features = ["derive"] }
+serde_json = "1.0.64"
+tide = { version = "0.16.0", default-features = false, features = ["h1-server", "cookies"] }
+time = "0.2.25"
--- a/14
+++ b/14
@ -1,9 +1,17 @@
-FROM rust:alpine as builder
+FROM rust:latest as builder
+
 WORKDIR /usr/src/libreddit
 COPY . .
-RUN apk add --no-cache g++ openssl-dev
 RUN cargo install --path .

-FROM alpine:latest
+
+FROM debian:buster-slim
+
+RUN apt-get update && apt-get install -y libcurl4 && rm -rf /var/lib/apt/lists/*
 COPY --from=builder /usr/local/cargo/bin/libreddit /usr/local/bin/libreddit
+RUN useradd --system --user-group --home-dir /nonexistent --no-create-home --shell /usr/sbin/nologin libreddit
+USER libreddit
+
+EXPOSE 8080
+
 CMD ["libreddit"]
--- a/README.md
+++ b/README.md
@ -2,11 +2,11 @@

 > An alternative private front-end to Reddit 

-![screenshot](https://i.ibb.co/185749F/image.png)
+![screenshot](https://i.ibb.co/74gZ4pd/libreddit-rust.png)

 ---

-**10 second pitch:** Libreddit is a portmanteau of "libre" (meaning freedom) and "Reddit". It is a private front-end like [Invidious](https://github.com/iv-org/invidious) but for Reddit. Browse the coldest takes of [r/unpopularopinion](https://libredd.it/r/unpopularopinion) without being [tracked](#reddit).
+**10 second pitch:** Libreddit is a portmanteau of "libre" (meaning freedom) and "Reddit". It is a private front-end like [Invidious](https://github.com/iv-org/invidious) but for Reddit. Browse the coldest takes of [r/unpopularopinion](https://libreddit.spike.codes/r/unpopularopinion) without being [tracked](#reddit).

 - 🚀 Fast: written in Rust for blazing fast speeds and memory safety
 - ☁️ Light: no JavaScript, no ads, no tracking, no bloat
@ -15,16 +15,22 @@

 ---

+**BTC:** bc1qwyxjnafpu3gypcpgs025cw9wa7ryudtecmwa6y
+
+**XMR:** 45FJrEuFPtG2o7QZz2Nps77TbHD4sPqxViwbdyV9A6ktfHiWs47UngG5zXPcLoDXAc8taeuBgeNjfeprwgeXYXhN3C9tVSR
+
+---
+
 ## Jump to...
 - [About](#about)
  - [Teddit Comparison](#how-does-it-compare-to-teddit)
 - [Comparison](#comparison)
 - [Installation](#installation)
-  - [Cargo](#a-cargo)
-  - [Docker](#b-docker)
-  - [AUR](#c-aur)
-  - [GitHub Releases](#d-github-releases)
-  - [Repl.it](#e-replit)
+  - [Cargo](#1-cargo)
+  - [Docker](#2-docker)
+  - [AUR](#3-aur)
+  - [GitHub Releases](#4-github-releases)
+  - [Replit](#5-replit)
 - [Deployment](#deployment)

 ---
@ -37,11 +43,14 @@ Feel free to [open an issue](https://github.com/spikecodes/libreddit/issues/new)
 |-|-|-|
 | [libredd.it](https://libredd.it) (official) | 🇺🇸 US |  |
 | [libreddit.spike.codes](https://libreddit.spike.codes) (official) | 🇺🇸 US |  |
-| [libreddit.dothq.co](https://libreddit.dothq.co) | 🇺🇸 US  | ✅ |
-| [libreddit.insanity.wtf](https://libreddit.insanity.wtf) | 🇺🇸 US  | ✅ |
+| [libreddit.dothq.co](https://libreddit.dothq.co) | 🇺🇸 US |  |
 | [libreddit.kavin.rocks](https://libreddit.kavin.rocks) | 🇮🇳 IN | ✅ |
-| [libreddit.himiko.cloud](https://libreddit.himiko.cloud) | 🇧🇬 BG |  |
+| [libreddit.himiko.cloud](https://libreddit.himiko.cloud) | 🇫🇮 FI |  |
+| [libreddit.bcow.xyz](https://libreddit.bcow.xyz) | 🇺🇸 US |  |
 | [spjmllawtheisznfs7uryhxumin26ssv2draj7oope3ok3wuhy43eoyd.onion](http://spjmllawtheisznfs7uryhxumin26ssv2draj7oope3ok3wuhy43eoyd.onion) | 🇮🇳 IN  |  |
+| [fwhhsbrbltmrct5hshrnqlqygqvcgmnek3cnka55zj4y7nuus5muwyyd.onion](http://fwhhsbrbltmrct5hshrnqlqygqvcgmnek3cnka55zj4y7nuus5muwyyd.onion) | 🇩🇪 DE  |  |
+| [libreddit.himiko7xl2skojc6odi7hykl626gt4qki3vxdbv33u2u3af76d6k32ad.onion](http://libreddit.himiko7xl2skojc6odi7hykl626gt4qki3vxdbv33u2u3af76d6k32ad.onion) | 🇫🇮 FI |  |
+| [dflv6yjt7il3n3tggf4qhcmkzbti2ppytqx3o7pjrzwgntutpewscyid.onion](http://dflv6yjt7il3n3tggf4qhcmkzbti2ppytqx3o7pjrzwgntutpewscyid.onion/) | 🇺🇸 US |  |

 A checkmark in the "Cloudflare" category here refers to the use of the reverse proxy, [Cloudflare](https://cloudflare). The checkmark will not be listed for a site which uses Cloudflare DNS but rather the proxying service which grants Cloudflare the ability to monitor traffic to the website.

@ -54,9 +63,9 @@ Find Libreddit on 💬 [Matrix](https://matrix.to/#/#libreddit:kde.org), 🐋 [D
 ## Built with

 - [Rust](https://www.rust-lang.org/) - Programming language
- [Actix Web](https://github.com/actix/actix-web) - Web server
+- [Tide](https://github.com/http-rs/tide) - Web server
 - [Askama](https://github.com/djc/askama) - Templating engine
- [ureq](https://github.com/algesten/ureq) - HTTP client
+- [Surf](https://github.com/http-rs/surf) - HTTP client

 ## Info
 Libreddit hopes to provide an easier way to browse Reddit, without the ads, trackers, and bloat. Libreddit was inspired by other alternative front-ends to popular services such as [Invidious](https://github.com/iv-org/invidious) for YouTube, [Nitter](https://github.com/zedeus/nitter) for Twitter, and [Bibliogram](https://sr.ht/~cadence/bibliogram/) for Instagram.
@ -128,9 +137,9 @@ For transparency, I hope to describe all the ways Libreddit handles user privacy

 **DNS:** Both official domains (`libredd.it` and `libreddit.spike.codes`) use Cloudflare as the DNS resolver. Though, the sites are not proxied through Cloudflare meaning Cloudflare doesn't have access to user traffic.

-**Cookies:** Libreddit uses optional cookies to store any configured settings in [the settings menu](https://libredd.it/settings). This is not a cross-site cookie and the cookie holds no personal data, only a value of the possible layout.
+**Cookies:** Libreddit uses optional cookies to store any configured settings in [the settings menu](https://libreddit.spike.codes/settings). This is not a cross-site cookie and the cookie holds no personal data, only a value of the possible layout.

-**Hosting:** The official instances are hosted on [Repl.it](https://repl.it/) which monitors usage to prevent abuse. I can understand if this invalidates certain users' threat models and therefore, selfhosting and browsing through Tor are welcomed.
+**Hosting:** The official instances are hosted on [Replit](https://replit.com/) which monitors usage to prevent abuse. I can understand if this invalidates certain users' threat models and therefore, selfhosting and browsing through Tor are welcomed.

 ---

@ -168,15 +177,15 @@ yay -S libreddit-git

 If you're on Linux and none of these methods work for you, you can grab a Linux binary from [the newest release](https://github.com/spikecodes/libreddit/releases/latest).

-## 5) Repl.it
+## 5) Replit

-**Note:** Repl.it is a free option but they are *not* private and will monitor server usage to prevent abuse. If you need a free and easy setup, this method may work best for you.
+**Note:** Replit is a free option but they are *not* private and will monitor server usage to prevent abuse. If you need a free and easy setup, this method may work best for you.

-1. Create a Repl.it account (see note above)
-2. Visit [the official Repl](https://repl.it/@spikethecoder/libreddit) and fork it
+1. Create a Replit account (see note above)
+2. Visit [the official Repl](https://replit.com/@spikethecoder/libreddit) and fork it
 3. Hit the run button to download the latest Libreddit version and start it

-In the web preview (defaults to top right), you should see your instance hosted where you can assign a [custom domain](https://docs.repl.it/repls/web-hosting#custom-domains).
+In the web preview (defaults to top right), you should see your instance hosted where you can assign a [custom domain](https://docs.replit.com/repls/web-hosting#custom-domains).

 ---

@ -188,12 +197,13 @@ Once installed, deploy Libreddit to `0.0.0.0:8080` by running:
 libreddit
 ```

-## Options
+## Proxying using NGINX

-| Short | Long               | Example                           |
-|-------|--------------------|-----------------------------------|
-| `-a`  | `--address`        | `libreddit --adress=0.0.0.0:8111` |
-| `-r`  | `--redirect-https` | `libreddit --redirect-https`      |
+**NOTE** If you're [proxying Libreddit through a NGINX Reverse Proxy](https://github.com/spikecodes/libreddit/issues/122#issuecomment-782226853), add
+```nginx
+proxy_http_version 1.1;
+```
+to your NGINX configuration file above your `proxy_pass` line.

 ## Building

--- a/src/main.rs
+++ b/src/main.rs
@ -1,9 +1,13 @@
-// Import Crates
-use actix_web::{
-	dev::{Service, ServiceResponse},
-	middleware, web, App, HttpResponse, HttpServer,
-};
-use futures::future::FutureExt;
+// Global specifiers
+#![forbid(unsafe_code)]
+#![warn(clippy::pedantic, clippy::all)]
+#![allow(
+	clippy::needless_pass_by_value,
+	clippy::match_wildcard_for_single_variants,
+	clippy::cast_possible_truncation,
+	clippy::similar_names,
+	clippy::cast_possible_wrap
+)]

 // Reference local files
 mod post;
@ -14,129 +18,260 @@ mod subreddit;
 mod user;
 mod utils;

+// Import Crates
+use clap::{App, Arg};
+use proxy::handler;
+use tide::{
+	utils::{async_trait, After},
+	Middleware, Next, Request, Response,
+};
+use utils::{error, redirect};
+
+// Build middleware
+struct HttpsRedirect<HttpsOnly>(HttpsOnly);
+struct NormalizePath;
+
+#[async_trait]
+impl<State, HttpsOnly> Middleware<State> for HttpsRedirect<HttpsOnly>
+where
+	State: Clone + Send + Sync + 'static,
+	HttpsOnly: Into<bool> + Copy + Send + Sync + 'static,
+{
+	async fn handle(&self, request: Request<State>, next: Next<'_, State>) -> tide::Result {
+		let secure = request.url().scheme() == "https";
+
+		if self.0.into() && !secure {
+			let mut secured = request.url().to_owned();
+			secured.set_scheme("https").unwrap_or_default();
+
+			Ok(redirect(secured.to_string()))
+		} else {
+			Ok(next.run(request).await)
+		}
+	}
+}
+
+#[async_trait]
+impl<State: Clone + Send + Sync + 'static> Middleware<State> for NormalizePath {
+	async fn handle(&self, request: Request<State>, next: Next<'_, State>) -> tide::Result {
+		let path = request.url().path();
+		let query = request.url().query().unwrap_or_default();
+		if path.ends_with('/') {
+			Ok(next.run(request).await)
+		} else {
+			let normalized = if query.is_empty() {
+				format!("{}/", path.replace("//", "/"))
+			} else {
+				format!("{}/?{}", path.replace("//", "/"), query)
+			};
+			Ok(redirect(normalized))
+		}
+	}
+}
+
 // Create Services
-async fn style() -> HttpResponse {
-	HttpResponse::Ok().content_type("text/css").body(include_str!("../static/style.css"))
+
+// Required for the manifest to be valid
+async fn pwa_logo(_req: Request<()>) -> tide::Result {
+	Ok(Response::builder(200).content_type("image/png").body(include_bytes!("../static/logo.png").as_ref()).build())
 }

-async fn robots() -> HttpResponse {
-	HttpResponse::Ok()
-		.header("Cache-Control", "public, max-age=1209600, s-maxage=86400")
-		.body("User-agent: *\nAllow: /")
+// Required for iOS App Icons
+async fn iphone_logo(_req: Request<()>) -> tide::Result {
+	Ok(
+		Response::builder(200)
+			.content_type("image/png")
+			.body(include_bytes!("../static/apple-touch-icon.png").as_ref())
+			.build(),
+	)
 }

-async fn favicon() -> HttpResponse {
-	HttpResponse::Ok()
-		.content_type("image/x-icon")
+async fn favicon(_req: Request<()>) -> tide::Result {
+	Ok(
+		Response::builder(200)
+			.content_type("image/vnd.microsoft.icon")
 			.header("Cache-Control", "public, max-age=1209600, s-maxage=86400")
 			.body(include_bytes!("../static/favicon.ico").as_ref())
+			.build(),
+	)
 }

-#[actix_web::main]
-async fn main() -> std::io::Result<()> {
-	let mut address = "0.0.0.0:8080".to_string();
-	let mut force_https = false;
+async fn resource(body: &str, content_type: &str, cache: bool) -> tide::Result {
+	let mut res = Response::new(200);

-	for arg in std::env::args().collect::<Vec<String>>() {
-		match arg.split('=').collect::<Vec<&str>>()[0] {
-			"--address" | "-a" => address = arg.split('=').collect::<Vec<&str>>()[1].to_string(),
-			"--redirect-https" | "-r" => force_https = true,
-			_ => (),
-		}
+	if cache {
+		res.insert_header("Cache-Control", "public, max-age=1209600, s-maxage=86400");
 	}

-	// start http server
-	println!("Running Libreddit v{} on {}!", env!("CARGO_PKG_VERSION"), &address);
+	res.set_content_type(content_type);
+	res.set_body(body);
+
+	Ok(res)
+}
+
+#[async_std::main]
+async fn main() -> tide::Result<()> {
+	let matches = App::new("Libreddit")
+		.version(env!("CARGO_PKG_VERSION"))
+		.about("Private front-end for Reddit written in Rust ")
+		.arg(
+			Arg::with_name("address")
+				.short("a")
+				.long("address")
+				.value_name("ADDRESS")
+				.help("Sets address to listen on")
+				.default_value("0.0.0.0")
+				.takes_value(true),
+		)
+		.arg(
+			Arg::with_name("port")
+				.short("p")
+				.long("port")
+				.value_name("PORT")
+				.help("Port to listen on")
+				.default_value("8080")
+				.takes_value(true),
+		)
+		.arg(
+			Arg::with_name("redirect-https")
+				.short("r")
+				.long("redirect-https")
+				.help("Redirect all HTTP requests to HTTPS")
+				.takes_value(false),
+		)
+		.get_matches();
+
+	let address = matches.value_of("address").unwrap_or("0.0.0.0");
+	let port = matches.value_of("port").unwrap_or("8080");
+	let force_https = matches.is_present("redirect-https");
+
+	let listener = format!("{}:{}", address, port);
+
+	println!("Starting Libreddit...");
+
+	// Start HTTP server
+	let mut app = tide::new();

-	HttpServer::new(move || {
-		App::new()
 	// Redirect to HTTPS if "--redirect-https" enabled
-			.wrap_fn(move |req, srv| {
-				let secure = req.connection_info().scheme() == "https";
-				let https_url = format!("https://{}{}", req.connection_info().host(), req.uri().to_string());
-				srv.call(req).map(move |res: Result<ServiceResponse, _>| {
-					if force_https && !secure {
-						Ok(ServiceResponse::new(
-							res.unwrap().request().to_owned(),
-							HttpResponse::Found().header("Location", https_url).finish(),
-						))
-					} else {
-						res
-					}
-				})
-			})
+	app.with(HttpsRedirect(force_https));
+
 	// Append trailing slash and remove double slashes
-			.wrap(middleware::NormalizePath::default())
+	app.with(NormalizePath);
+
 	// Apply default headers for security
-			.wrap(
-				middleware::DefaultHeaders::new()
-					.header("Referrer-Policy", "no-referrer")
-					.header("X-Content-Type-Options", "nosniff")
-					.header("X-Frame-Options", "DENY")
-					.header(
+	app.with(After(|mut res: Response| async move {
+		res.insert_header("Referrer-Policy", "no-referrer");
+		res.insert_header("X-Content-Type-Options", "nosniff");
+		res.insert_header("X-Frame-Options", "DENY");
+		res.insert_header(
 			"Content-Security-Policy",
-						"default-src 'none'; media-src 'self'; style-src 'self' 'unsafe-inline'; base-uri 'none'; img-src 'self' data:; form-action 'self'; frame-ancestors 'none';",
-					),
-			)
-			// Default service in case no routes match
-			.default_service(web::get().to(|| utils::error("Nothing here".to_string())))
+			"default-src 'none'; manifest-src 'self'; media-src 'self'; style-src 'self' 'unsafe-inline'; base-uri 'none'; img-src 'self' data:; form-action 'self'; frame-ancestors 'none';",
+		);
+		Ok(res)
+	}));
+
 	// Read static files
-			.route("/style.css/", web::get().to(style))
-			.route("/favicon.ico/", web::get().to(favicon))
-			.route("/robots.txt/", web::get().to(robots))
+	app.at("/style.css/").get(|_| resource(include_str!("../static/style.css"), "text/css", false));
+	app
+		.at("/manifest.json/")
+		.get(|_| resource(include_str!("../static/manifest.json"), "application/json", false));
+	app.at("/robots.txt/").get(|_| resource("User-agent: *\nAllow: /", "text/plain", true));
+	app.at("/favicon.ico/").get(favicon);
+	app.at("/logo.png/").get(pwa_logo);
+	app.at("/touch-icon-iphone.png/").get(iphone_logo);
+	app.at("/apple-touch-icon.png/").get(iphone_logo);
+
 	// Proxy media through Libreddit
-			.route("/proxy/{url:.*}/", web::get().to(proxy::handler))
+	app
+		.at("/vid/:id/:size/") /*      */
+		.get(|req| handler(req, "https://v.redd.it/{}/DASH_{}", vec!["id", "size"]));
+	app
+		.at("/img/:id/") /*            */
+		.get(|req| handler(req, "https://i.redd.it/{}", vec!["id"]));
+	app
+		.at("/thumb/:point/:id/") /*   */
+		.get(|req| handler(req, "https://{}.thumbs.redditmedia.com/{}", vec!["point", "id"]));
+	app
+		.at("/emoji/:id/:name/") /*    */
+		.get(|req| handler(req, "https://emoji.redditmedia.com/{}/{}", vec!["id", "name"]));
+	app
+		.at("/preview/:loc/:id/:query/")
+		.get(|req| handler(req, "https://{}view.redd.it/{}?{}", vec!["loc", "id", "query"]));
+	app
+		.at("/style/*path/") /*        */
+		.get(|req| handler(req, "https://styles.redditmedia.com/{}", vec!["path"]));
+	app
+		.at("/static/*path/") /*       */
+		.get(|req| handler(req, "https://www.redditstatic.com/{}", vec!["path"]));
+
 	// Browse user profile
-			.service(
-				web::scope("/{scope:user|u}").service(
-					web::scope("/{username}").route("/", web::get().to(user::profile)).service(
-						web::scope("/comments/{id}/{title}")
-							.route("/", web::get().to(post::item))
-							.route("/{comment_id}/", web::get().to(post::item)),
-					),
-				),
-			)
+	app.at("/u/:name/").get(user::profile);
+	app.at("/u/:name/comments/:id/:title/").get(post::item);
+	app.at("/u/:name/comments/:id/:title/:comment_id/").get(post::item);
+
+	app.at("/user/:name/").get(user::profile);
+	app.at("/user/:name/comments/:id/").get(post::item);
+	app.at("/user/:name/comments/:id/:title/").get(post::item);
+	app.at("/user/:name/comments/:id/:title/:comment_id/").get(post::item);
+
 	// Configure settings
-			.service(web::resource("/settings/").route(web::get().to(settings::get)).route(web::post().to(settings::set)))
+	app.at("/settings/").get(settings::get).post(settings::set);
+	app.at("/settings/restore/").get(settings::restore);
+
 	// Subreddit services
-			.service(
-				web::scope("/r/{sub}")
-					// See posts and info about subreddit
-					.route("/", web::get().to(subreddit::page))
-					.route("/{sort:hot|new|top|rising|controversial}/", web::get().to(subreddit::page))
-					// Handle subscribe/unsubscribe
-					.route("/{action:subscribe|unsubscribe}/", web::post().to(subreddit::subscriptions))
-					// View post on subreddit
-					.service(
-						web::scope("/comments/{id}/{title}")
-							.route("/", web::get().to(post::item))
-							.route("/{comment_id}/", web::get().to(post::item)),
-					)
-					// Search inside subreddit
-					.route("/search/", web::get().to(search::find))
-					// View wiki of subreddit
-					.service(
-						web::scope("/wiki")
-							.route("/", web::get().to(subreddit::wiki))
-							.route("/{page}/", web::get().to(subreddit::wiki)),
-					),
-			)
+	app.at("/r/:sub/").get(subreddit::community);
+
+	app.at("/r/:sub/subscribe/").post(subreddit::subscriptions);
+	app.at("/r/:sub/unsubscribe/").post(subreddit::subscriptions);
+
+	app.at("/r/:sub/comments/:id/").get(post::item);
+	app.at("/r/:sub/comments/:id/:title/").get(post::item);
+	app.at("/r/:sub/comments/:id/:title/:comment_id/").get(post::item);
+
+	app.at("/r/:sub/search/").get(search::find);
+
+	app.at("/r/:sub/wiki/").get(subreddit::wiki);
+	app.at("/r/:sub/wiki/:page/").get(subreddit::wiki);
+	app.at("/r/:sub/w/").get(subreddit::wiki);
+	app.at("/r/:sub/w/:page/").get(subreddit::wiki);
+
+	app.at("/r/:sub/:sort/").get(subreddit::community);
+
+	// Comments handler
+	app.at("/comments/:id/").get(post::item);
+
 	// Front page
-			.route("/", web::get().to(subreddit::page))
-			.route("/{sort:best|hot|new|top|rising|controversial}/", web::get().to(subreddit::page))
+	app.at("/").get(subreddit::community);
+
 	// View Reddit wiki
-			.service(
-				web::scope("/wiki")
-					.route("/", web::get().to(subreddit::wiki))
-					.route("/{page}/", web::get().to(subreddit::wiki)),
-			)
+	app.at("/w/").get(subreddit::wiki);
+	app.at("/w/:page/").get(subreddit::wiki);
+	app.at("/wiki/").get(subreddit::wiki);
+	app.at("/wiki/:page/").get(subreddit::wiki);
+
 	// Search all of Reddit
-			.route("/search/", web::get().to(search::find))
+	app.at("/search/").get(search::find);
+
+	// Handle about pages
+	app.at("/about/").get(|req| error(req, "About pages aren't here yet".to_string()));
+
+	app.at("/:id/").get(|req: Request<()>| async {
+		match req.param("id") {
+			// Sort front page
+			Ok("best") | Ok("hot") | Ok("new") | Ok("top") | Ok("rising") | Ok("controversial") => subreddit::community(req).await,
 			// Short link for post
-			.route("/{id:.{5,6}}/", web::get().to(post::item))
-	})
-	.bind(&address)
-	.unwrap_or_else(|e| panic!("Cannot bind to the address {}: {}", address, e))
-	.run()
-	.await
+			Ok(id) if id.len() > 4 && id.len() < 7 => post::item(req).await,
+			// Error message for unknown pages
+			_ => error(req, "Nothing here".to_string()).await,
+		}
+	});
+
+	// Default service in case no routes match
+	app.at("*").get(|req| error(req, "Nothing here".to_string()));
+
+	println!("Running Libreddit v{} on {}!", env!("CARGO_PKG_VERSION"), listener);
+
+	app.listen(&listener).await?;
+
+	Ok(())
 }
--- a/src/post.rs
+++ b/src/post.rs
@ -1,6 +1,9 @@
 // CRATES
-use crate::utils::*;
-use actix_web::{HttpRequest, HttpResponse};
+use crate::esc;
+use crate::utils::{
+	cookie, error, format_num, format_url, param, request, rewrite_urls, template, time, val, Author, Comment, Flags, Flair, FlairPart, Media, Post, Preferences,
+};
+use tide::Request;

 use async_recursion::async_recursion;

@ -14,11 +17,12 @@ struct PostTemplate {
 	post: Post,
 	sort: String,
 	prefs: Preferences,
+	single_thread: bool,
 }

-pub async fn item(req: HttpRequest) -> HttpResponse {
+pub async fn item(req: Request<()>) -> tide::Result {
 	// Build Reddit API path
-	let mut path: String = format!("{}.json?{}&raw_json=1", req.path(), req.query_string());
+	let mut path: String = format!("{}.json?{}&raw_json=1", req.url().path(), req.url().query().unwrap_or_default());

 	// Set sort to sort query parameter
 	let mut sort: String = param(&path, "sort");
@ -29,12 +33,15 @@ pub async fn item(req: HttpRequest) -> HttpResponse {
 	// If there's no sort query but there's a default sort, set sort to default_sort
 	if sort.is_empty() && !default_sort.is_empty() {
 		sort = default_sort;
-		path = format!("{}.json?{}&sort={}&raw_json=1", req.path(), req.query_string(), sort);
+		path = format!("{}.json?{}&sort={}&raw_json=1", req.url().path(), req.url().query().unwrap_or_default(), sort);
 	}

 	// Log the post ID being fetched in debug mode
 	#[cfg(debug_assertions)]
-	dbg!(req.match_info().get("id").unwrap_or(""));
+	dbg!(req.param("id").unwrap_or(""));
+
+	let single_thread = &req.param("comment_id").is_ok();
+	let highlighted_comment = &req.param("comment_id").unwrap_or_default();

 	// Send a request to the url, receive JSON in response
 	match request(path).await {
@ -42,21 +49,19 @@ pub async fn item(req: HttpRequest) -> HttpResponse {
 		Ok(res) => {
 			// Parse the JSON into Post and Comment structs
 			let post = parse_post(&res[0]).await;
-			let comments = parse_comments(&res[1]).await;
+			let comments = parse_comments(&res[1], &post.permalink, &post.author.name, *highlighted_comment).await;

 			// Use the Post and Comment structs to generate a website to show users
-			let s = PostTemplate {
+			template(PostTemplate {
 				comments,
 				post,
 				sort,
-				prefs: prefs(req),
-			}
-			.render()
-			.unwrap();
-			HttpResponse::Ok().content_type("text/html").body(s)
+				prefs: Preferences::new(req),
+				single_thread: *single_thread,
+			})
 		}
 		// If the Reddit API returns an error, exit and send error page to user
-		Err(msg) => error(msg).await,
+		Err(msg) => error(req, msg).await,
 	}
 }

@ -72,22 +77,23 @@ async fn parse_post(json: &serde_json::Value) -> Post {
 	let ratio: f64 = post["data"]["upvote_ratio"].as_f64().unwrap_or(1.0) * 100.0;

 	// Determine the type of media along with the media URL
-	let (post_type, media) = media(&post["data"]).await;
+	let (post_type, media, gallery) = Media::parse(&post["data"]).await;

 	// Build a post using data parsed from Reddit post API
 	Post {
 		id: val(post, "id"),
-		title: val(post, "title"),
+		title: esc!(post, "title"),
 		community: val(post, "subreddit"),
-		body: rewrite_url(&val(post, "selftext_html")),
+		body: rewrite_urls(&val(post, "selftext_html")).replace("\\", ""),
 		author: Author {
 			name: val(post, "author"),
 			flair: Flair {
-				flair_parts: parse_rich_flair(
-					val(post, "author_flair_type"),
+				flair_parts: FlairPart::parse(
+					post["data"]["author_flair_type"].as_str().unwrap_or_default(),
 					post["data"]["author_flair_richtext"].as_array(),
 					post["data"]["author_flair_text"].as_str(),
 				),
+				text: esc!(post, "link_flair_text"),
 				background_color: val(post, "author_flair_background_color"),
 				foreground_color: val(post, "author_flair_text_color"),
 			},
@ -102,13 +108,15 @@ async fn parse_post(json: &serde_json::Value) -> Post {
 			url: format_url(val(post, "thumbnail").as_str()),
 			width: post["data"]["thumbnail_width"].as_i64().unwrap_or_default(),
 			height: post["data"]["thumbnail_height"].as_i64().unwrap_or_default(),
+			poster: "".to_string(),
 		},
 		flair: Flair {
-			flair_parts: parse_rich_flair(
-				val(post, "link_flair_type"),
+			flair_parts: FlairPart::parse(
+				post["data"]["link_flair_type"].as_str().unwrap_or_default(),
 				post["data"]["link_flair_richtext"].as_array(),
 				post["data"]["link_flair_text"].as_str(),
 			),
+			text: esc!(post, "link_flair_text"),
 			background_color: val(post, "link_flair_background_color"),
 			foreground_color: if val(post, "link_flair_text_color") == "dark" {
 				"black".to_string()
@ -124,12 +132,13 @@ async fn parse_post(json: &serde_json::Value) -> Post {
 		rel_time,
 		created,
 		comments: format_num(post["data"]["num_comments"].as_i64().unwrap_or_default()),
+		gallery,
 	}
 }

 // COMMENTS
 #[async_recursion]
-async fn parse_comments(json: &serde_json::Value) -> Vec<Comment> {
+async fn parse_comments(json: &serde_json::Value, post_link: &str, post_author: &str, highlighted_comment: &str) -> Vec<Comment> {
 	// Separate the comment JSON into a Vector of comments
 	let comment_data = match json["data"]["children"].as_array() {
 		Some(f) => f.to_owned(),
@ -140,47 +149,65 @@ async fn parse_comments(json: &serde_json::Value) -> Vec<Comment> {

 	// For each comment, retrieve the values to build a Comment object
 	for comment in comment_data {
-		let unix_time = comment["data"]["created_utc"].as_f64().unwrap_or_default();
-		if unix_time == 0.0 {
-			continue;
-		}
+		let kind = comment["kind"].as_str().unwrap_or_default().to_string();
+		let data = &comment["data"];
+
+		let unix_time = data["created_utc"].as_f64().unwrap_or_default();
 		let (rel_time, created) = time(unix_time);

-		let score = comment["data"]["score"].as_i64().unwrap_or(0);
-		let body = rewrite_url(&val(&comment, "body_html"));
+		let edited = match data["edited"].as_f64() {
+			Some(stamp) => time(stamp),
+			None => (String::new(), String::new()),
+		};

-		let replies: Vec<Comment> = if comment["data"]["replies"].is_object() {
-			parse_comments(&comment["data"]["replies"]).await
+		let score = data["score"].as_i64().unwrap_or(0);
+		let body = rewrite_urls(&val(&comment, "body_html"));
+
+		// If this comment contains replies, handle those too
+		let replies: Vec<Comment> = if data["replies"].is_object() {
+			parse_comments(&data["replies"], post_link, post_author, highlighted_comment).await
 		} else {
 			Vec::new()
 		};

-		dbg!();
+		let parent_kind_and_id = val(&comment, "parent_id");
+		let parent_info = parent_kind_and_id.split('_').collect::<Vec<&str>>();
+
+		let id = val(&comment, "id");
+		let highlighted = id == highlighted_comment;

 		comments.push(Comment {
-			id: val(&comment, "id"),
+			id,
+			kind,
+			parent_id: parent_info[1].to_string(),
+			parent_kind: parent_info[0].to_string(),
+			post_link: post_link.to_string(),
+			post_author: post_author.to_string(),
 			body,
 			author: Author {
 				name: val(&comment, "author"),
 				flair: Flair {
-					flair_parts: parse_rich_flair(
-						val(&comment, "author_flair_type"),
-						comment["data"]["author_flair_richtext"].as_array(),
-						comment["data"]["author_flair_text"].as_str(),
+					flair_parts: FlairPart::parse(
+						data["author_flair_type"].as_str().unwrap_or_default(),
+						data["author_flair_richtext"].as_array(),
+						data["author_flair_text"].as_str(),
 					),
+					text: esc!(&comment, "link_flair_text"),
 					background_color: val(&comment, "author_flair_background_color"),
 					foreground_color: val(&comment, "author_flair_text_color"),
 				},
 				distinguished: val(&comment, "distinguished"),
 			},
-			score: if comment["data"]["score_hidden"].as_bool().unwrap_or_default() {
-				"•".to_string()
+			score: if data["score_hidden"].as_bool().unwrap_or_default() {
+				"\u{2022}".to_string()
 			} else {
 				format_num(score)
 			},
 			rel_time,
 			created,
+			edited,
 			replies,
+			highlighted,
 		});
 	}

--- a/src/proxy.rs
+++ b/src/proxy.rs
@ -1,47 +1,88 @@
-use actix_web::{client::Client, error, web, Error, HttpResponse, Result};
-use url::Url;
+use async_std::{io, net::TcpStream, prelude::*};
+use async_tls::TlsConnector;
+use tide::{http::url::Url, Request, Response};

-use base64::decode;
+/// Handle tide routes to proxy by parsing `params` from `req`uest.
+pub async fn handler(req: Request<()>, format: &str, params: Vec<&str>) -> tide::Result {
+	let mut url = format.to_string();

-pub async fn handler(web::Path(b64): web::Path<String>) -> Result<HttpResponse> {
-	let domains = vec![
-		// THUMBNAILS
-		"a.thumbs.redditmedia.com",
-		"b.thumbs.redditmedia.com",
-		// EMOJI
-		"emoji.redditmedia.com",
-		// ICONS
-		"styles.redditmedia.com",
-		"www.redditstatic.com",
-		// PREVIEWS
-		"preview.redd.it",
-		"external-preview.redd.it",
-		// MEDIA
-		"i.redd.it",
-		"v.redd.it",
-	];
+	for name in params {
+		let param = req.param(name).unwrap_or_default();
+		url = url.replacen("{}", param, 1);
+	}

-	let decoded = decode(b64).map(|bytes| String::from_utf8(bytes).unwrap_or_default());
+	request(url).await
+}

-	match decoded {
-		Ok(media) => match Url::parse(media.as_str()) {
-			Ok(url) => {
-				let domain = url.domain().unwrap_or_default();
+/// Sends a request to a Reddit media domain and proxy the response.
+///
+/// Relays the `Content-Length` and `Content-Type` header.
+async fn request(url: String) -> tide::Result {
+	// Parse url into parts
+	let parts = Url::parse(&url)?;
+	let host = parts.host().map(|host| host.to_string()).unwrap_or_default();
+	let domain = parts.domain().unwrap_or_default();
+	let path = format!("{}?{}", parts.path(), parts.query().unwrap_or_default());
+	// Build reddit-compliant user agent for Libreddit
+	let user_agent = format!("web:libreddit:{}", env!("CARGO_PKG_VERSION"));

-				if domains.contains(&domain) {
-					Client::default().get(media.replace("&amp;", "&")).send().await.map_err(Error::from).map(|res| {
-						HttpResponse::build(res.status())
+	// Construct a request body
+	let req = format!(
+		"GET {} HTTP/1.1\r\nHost: {}\r\nAccept: */*\r\nConnection: close\r\nUser-Agent: {}\r\n\r\n",
+		path, host, user_agent
+	);
+
+	// Initialize TLS connector for requests
+	let connector = TlsConnector::default();
+
+	// Open a TCP connection
+	let tcp_stream = TcpStream::connect(format!("{}:443", domain)).await?;
+
+	// Use the connector to start the handshake process
+	let mut tls_stream = connector.connect(domain, tcp_stream).await?;
+
+	// Write the aforementioned HTTP request to the stream
+	tls_stream.write_all(req.as_bytes()).await?;
+
+	// And read the response
+	let mut writer = Vec::new();
+	io::copy(&mut tls_stream, &mut writer).await?;
+
+	// Find the delimiter which separates the body and headers
+	match (0..writer.len()).find(|i| writer[i.to_owned()] == 10_u8 && writer[i - 2] == 10_u8) {
+		Some(delim) => {
+			// Split the response into the body and headers
+			let split = writer.split_at(delim);
+			let headers_str = String::from_utf8_lossy(split.0);
+			let headers = headers_str.split("\r\n").collect::<Vec<&str>>();
+			let body = split.1[1..split.1.len()].to_vec();
+
+			// Parse the status code from the first header line
+			let status: u16 = headers[0].split(' ').collect::<Vec<&str>>()[1].parse().unwrap_or_default();
+
+			// Define a closure for easier header fetching
+			let header = |name: &str| {
+				headers
+					.iter()
+					.find(|x| x.starts_with(name))
+					.map(|f| f.split(": ").collect::<Vec<&str>>()[1])
+					.unwrap_or_default()
+			};
+
+			// Parse Content-Length and Content-Type from headers
+			let content_length = header("Content-Length");
+			let content_type = header("Content-Type");
+
+			// Build response
+			Ok(
+				Response::builder(status)
+					.body(tide::http::Body::from_bytes(body))
 					.header("Cache-Control", "public, max-age=1209600, s-maxage=86400")
-							.header("Content-Length", res.headers().get("Content-Length").unwrap().to_owned())
-							.header("Content-Type", res.headers().get("Content-Type").unwrap().to_owned())
-							.streaming(res)
-					})
-				} else {
-					Err(error::ErrorForbidden("Resource must be from Reddit"))
+					.header("Content-Length", content_length)
+					.header("Content-Type", content_type)
+					.build(),
+			)
 		}
-			}
-			_ => Err(error::ErrorBadRequest("Can't parse base64 into URL")),
-		},
-		_ => Err(error::ErrorBadRequest("Can't decode base64")),
+		None => Ok(Response::builder(503).body("Couldn't parse media".to_string()).build()),
 	}
 }
--- a/src/search.rs
+++ b/src/search.rs
@ -1,7 +1,7 @@
 // CRATES
-use crate::utils::{cookie, error, fetch_posts, param, prefs, request, val, Post, Preferences};
-use actix_web::{HttpRequest, HttpResponse};
+use crate::utils::{cookie, error, param, request, template, val, Post, Preferences};
 use askama::Template;
+use tide::Request;

 // STRUCTS
 struct SearchParams {
@ -32,10 +32,11 @@ struct SearchTemplate {
 }

 // SERVICES
-pub async fn find(req: HttpRequest) -> HttpResponse {
+pub async fn find(req: Request<()>) -> tide::Result {
 	let nsfw_results = if cookie(&req, "show_nsfw") == "on" { "&include_over_18=on" } else { "" };
-	let path = format!("{}.json?{}{}", req.path(), req.query_string(), nsfw_results);
-	let sub = req.match_info().get("sub").unwrap_or("").to_string();
+	let path = format!("{}.json?{}{}", req.url().path(), req.url().query().unwrap_or_default(), nsfw_results);
+	let sub = req.param("sub").unwrap_or("").to_string();
+	let query = param(&path, "q");

 	let sort = if param(&path, "sort").is_empty() {
 		"relevance".to_string()
@ -44,35 +45,31 @@ pub async fn find(req: HttpRequest) -> HttpResponse {
 	};

 	let subreddits = if param(&path, "restrict_sr").is_empty() {
-		search_subreddits(param(&path, "q")).await
+		search_subreddits(&query).await
 	} else {
 		Vec::new()
 	};

-	match fetch_posts(&path, String::new()).await {
-		Ok((posts, after)) => HttpResponse::Ok().content_type("text/html").body(
-			SearchTemplate {
+	match Post::fetch(&path, String::new()).await {
+		Ok((posts, after)) => template(SearchTemplate {
 			posts,
 			subreddits,
 			sub,
 			params: SearchParams {
-					q: param(&path, "q"),
+				q: query.replace('"', "&quot;"),
 				sort,
 				t: param(&path, "t"),
 				before: param(&path, "after"),
 				after,
 				restrict_sr: param(&path, "restrict_sr"),
 			},
-				prefs: prefs(req),
-			}
-			.render()
-			.unwrap(),
-		),
-		Err(msg) => error(msg).await,
+			prefs: Preferences::new(req),
+		}),
+		Err(msg) => error(req, msg).await,
 	}
 }

-async fn search_subreddits(q: String) -> Vec<Subreddit> {
+async fn search_subreddits(q: &str) -> Vec<Subreddit> {
 	let subreddit_search_path = format!("/subreddits/search.json?q={}&limit=3", q.replace(' ', "+"));

 	// Send a request to the url
@ -87,7 +84,7 @@ async fn search_subreddits(q: String) -> Vec<Subreddit> {
 						name: val(subreddit, "display_name_prefixed"),
 						url: val(subreddit, "url"),
 						description: val(subreddit, "public_description"),
-						subscribers: subreddit["data"]["subscribers"].as_u64().unwrap_or_default() as i64,
+						subscribers: subreddit["data"]["subscribers"].as_f64().unwrap_or_default() as i64,
 					})
 					.collect::<Vec<Subreddit>>(),
 				_ => Vec::new(),
--- a/src/settings.rs
+++ b/src/settings.rs
@ -1,7 +1,7 @@
 // CRATES
-use crate::utils::{prefs, Preferences};
-use actix_web::{cookie::Cookie, web::Form, HttpRequest, HttpResponse};
+use crate::utils::{redirect, template, Preferences};
 use askama::Template;
+use tide::{http::Cookie, Request};
 use time::{Duration, OffsetDateTime};

 // STRUCTS
@ -11,46 +11,77 @@ struct SettingsTemplate {
 	prefs: Preferences,
 }

-#[derive(serde::Deserialize)]
-pub struct SettingsForm {
+#[derive(serde::Deserialize, Default)]
+#[serde(default)]
+pub struct Form {
 	theme: Option<String>,
 	front_page: Option<String>,
 	layout: Option<String>,
 	wide: Option<String>,
 	comment_sort: Option<String>,
 	show_nsfw: Option<String>,
+	redirect: Option<String>,
+	subscriptions: Option<String>,
 }

 // FUNCTIONS

 // Retrieve cookies from request "Cookie" header
-pub async fn get(req: HttpRequest) -> HttpResponse {
-	let s = SettingsTemplate { prefs: prefs(req) }.render().unwrap();
-	HttpResponse::Ok().content_type("text/html").body(s)
+pub async fn get(req: Request<()>) -> tide::Result {
+	template(SettingsTemplate { prefs: Preferences::new(req) })
 }

 // Set cookies using response "Set-Cookie" header
-pub async fn set(_req: HttpRequest, form: Form<SettingsForm>) -> HttpResponse {
-	let mut res = HttpResponse::Found();
+pub async fn set(mut req: Request<()>) -> tide::Result {
+	let form: Form = req.body_form().await.unwrap_or_default();
+
+	let mut res = redirect("/settings".to_string());

 	let names = vec!["theme", "front_page", "layout", "wide", "comment_sort", "show_nsfw"];
-	let values = vec![&form.theme, &form.front_page, &form.layout, &form.wide, &form.comment_sort, &form.show_nsfw];
+	let values = vec![form.theme, form.front_page, form.layout, form.wide, form.comment_sort, form.show_nsfw];

 	for (i, name) in names.iter().enumerate() {
-		match values[i] {
-			Some(value) => res.cookie(
-				Cookie::build(name.to_owned(), value)
+		match values.get(i) {
+			Some(value) => res.insert_cookie(
+				Cookie::build(name.to_owned(), value.to_owned().unwrap_or_default())
 					.path("/")
 					.http_only(true)
 					.expires(OffsetDateTime::now_utc() + Duration::weeks(52))
 					.finish(),
 			),
-			None => res.del_cookie(&Cookie::named(name.to_owned())),
+			None => res.remove_cookie(Cookie::named(name.to_owned())),
 		};
 	}

-	res
-		.content_type("text/html")
-		.set_header("Location", "/settings")
-		.body(r#"Redirecting to <a href="/settings">settings</a>..."#)
+	Ok(res)
+}
+
+// Set cookies using response "Set-Cookie" header
+pub async fn restore(req: Request<()>) -> tide::Result {
+	let form: Form = req.query()?;
+
+	let path = match form.redirect {
+		Some(value) => format!("/{}/", value),
+		None => "/".to_string(),
+	};
+
+	let mut res = redirect(path);
+
+	let names = vec!["theme", "front_page", "layout", "wide", "comment_sort", "show_nsfw", "subscriptions"];
+	let values = vec![form.theme, form.front_page, form.layout, form.wide, form.comment_sort, form.show_nsfw, form.subscriptions];
+
+	for (i, name) in names.iter().enumerate() {
+		match values.get(i) {
+			Some(value) => res.insert_cookie(
+				Cookie::build(name.to_owned(), value.to_owned().unwrap_or_default())
+					.path("/")
+					.http_only(true)
+					.expires(OffsetDateTime::now_utc() + Duration::weeks(52))
+					.finish(),
+			),
+			None => res.remove_cookie(Cookie::named(name.to_owned())),
+		};
+	}
+
+	Ok(res)
 }
--- a/src/subreddit.rs
+++ b/src/subreddit.rs
@ -1,7 +1,8 @@
 // CRATES
-use crate::utils::*;
-use actix_web::{cookie::Cookie, HttpRequest, HttpResponse, Result};
+use crate::esc;
+use crate::utils::{cookie, error, format_num, format_url, param, redirect, request, rewrite_urls, template, val, Post, Preferences, Subreddit};
 use askama::Template;
+use tide::{http::Cookie, Request};
 use time::{Duration, OffsetDateTime};

 // STRUCTS
@ -25,16 +26,13 @@ struct WikiTemplate {
 }

 // SERVICES
-pub async fn page(req: HttpRequest) -> HttpResponse {
+pub async fn community(req: Request<()>) -> tide::Result {
+	// Build Reddit API path
 	let subscribed = cookie(&req, "subscriptions");
 	let front_page = cookie(&req, "front_page");
-	let sort = req.match_info().get("sort").unwrap_or("hot").to_string();
+	let sort = req.param("sort").unwrap_or_else(|_| req.param("id").unwrap_or("hot")).to_string();

-	let sub = req
-		.match_info()
-		.get("sub")
-		.map(String::from)
-		.unwrap_or(if front_page == "default" || front_page.is_empty() {
+	let sub = req.param("sub").map(String::from).unwrap_or(if front_page == "default" || front_page.is_empty() {
 		if subscribed.is_empty() {
 			"popular".to_string()
 		} else {
@ -44,9 +42,9 @@ pub async fn page(req: HttpRequest) -> HttpResponse {
 		front_page.to_owned()
 	});

-	let path = format!("/r/{}/{}.json?{}", sub, sort, req.query_string());
+	let path = format!("/r/{}/{}.json?{}&raw_json=1", sub, sort, req.url().query().unwrap_or_default());

-	match fetch_posts(&path, String::new()).await {
+	match Post::fetch(&path, String::new()).await {
 		Ok((posts, after)) => {
 			// If you can get subreddit posts, also request subreddit metadata
 			let sub = if !sub.contains('+') && sub != subscribed && sub != "popular" && sub != "all" {
@ -54,7 +52,7 @@ pub async fn page(req: HttpRequest) -> HttpResponse {
 				subreddit(&sub).await.unwrap_or_default()
 			} else if sub == subscribed {
 				// Subscription feed
-				if req.path().starts_with("/r/") {
+				if req.url().path().starts_with("/r/") {
 					subreddit(&sub).await.unwrap_or_default()
 				} else {
 					Subreddit::default()
@ -69,42 +67,62 @@ pub async fn page(req: HttpRequest) -> HttpResponse {
 				Subreddit::default()
 			};

-			let s = SubredditTemplate {
+			template(SubredditTemplate {
 				sub,
 				posts,
 				sort: (sort, param(&path, "t")),
 				ends: (param(&path, "after"), after),
-				prefs: prefs(req),
+				prefs: Preferences::new(req),
+			})
 		}
-			.render()
-			.unwrap();
-			HttpResponse::Ok().content_type("text/html").body(s)
-		}
-		Err(msg) => error(msg).await,
+		Err(msg) => match msg.as_str() {
+			"quarantined" => error(req, format!("r/{} has been quarantined by Reddit", sub)).await,
+			"private" => error(req, format!("r/{} is a private community", sub)).await,
+			"banned" => error(req, format!("r/{} has been banned from Reddit", sub)).await,
+			_ => error(req, msg).await,
+		},
 	}
 }

 // Sub or unsub by setting subscription cookie using response "Set-Cookie" header
-pub async fn subscriptions(req: HttpRequest) -> HttpResponse {
-	let mut res = HttpResponse::Found();
+pub async fn subscriptions(req: Request<()>) -> tide::Result {
+	let sub = req.param("sub").unwrap_or_default().to_string();
+	let query = req.url().query().unwrap_or_default().to_string();
+	let action: Vec<String> = req.url().path().split('/').map(String::from).collect();

-	let sub = req.match_info().get("sub").unwrap_or_default().to_string();
-	let action = req.match_info().get("action").unwrap_or_default().to_string();
-	let mut sub_list = prefs(req.to_owned()).subs;
+	let mut sub_list = Preferences::new(req).subscriptions;

+	// Find each subreddit name (separated by '+') in sub parameter
+	for part in sub.split('+') {
 		// Modify sub list based on action
-	if action == "subscribe" && !sub_list.contains(&sub) {
-		sub_list.push(sub.to_owned());
-		sub_list.sort();
-	} else if action == "unsubscribe" {
-		sub_list.retain(|s| s != &sub);
+		if action.contains(&"subscribe".to_string()) && !sub_list.contains(&part.to_owned()) {
+			// Add each sub name to the subscribed list
+			sub_list.push(part.to_owned());
+			// Reorder sub names alphabettically
+			sub_list.sort_by_key(|a| a.to_lowercase())
+		} else if action.contains(&"unsubscribe".to_string()) {
+			// Remove sub name from subscribed list
+			sub_list.retain(|s| s != part);
 		}
+	}
+
+	// Redirect back to subreddit
+	// check for redirect parameter if unsubscribing from outside sidebar
+	let redirect_path = param(&format!("/?{}", query), "redirect");
+	let path = if redirect_path.is_empty() {
+		format!("/r/{}", sub)
+	} else {
+		format!("/{}/", redirect_path)
+	};
+
+	let mut res = redirect(path);

 	// Delete cookie if empty, else set
 	if sub_list.is_empty() {
-		res.del_cookie(&Cookie::build("subscriptions", "").path("/").finish());
+		// res.del_cookie(&Cookie::build("subscriptions", "").path("/").finish());
+		res.remove_cookie(Cookie::build("subscriptions", "").path("/").finish());
 	} else {
-		res.cookie(
+		res.insert_cookie(
 			Cookie::build("subscriptions", sub_list.join("+"))
 				.path("/")
 				.http_only(true)
@ -113,39 +131,22 @@ pub async fn subscriptions(req: HttpRequest) -> HttpResponse {
 		);
 	}

-	// Redirect back to subreddit
-	// check for redirect parameter if unsubscribing from outside sidebar
-	let redirect_path = param(&req.uri().to_string(), "redirect");
-	let path = if !redirect_path.is_empty() && redirect_path.starts_with('/') {
-		redirect_path
-	} else {
-		format!("/r/{}", sub)
-	};
-
-	res
-		.content_type("text/html")
-		.set_header("Location", path.to_owned())
-		.body(format!("Redirecting to <a href=\"{0}\">{0}</a>...", path))
+	Ok(res)
 }

-pub async fn wiki(req: HttpRequest) -> HttpResponse {
-	let sub = req.match_info().get("sub").unwrap_or("reddit.com").to_string();
-	let page = req.match_info().get("page").unwrap_or("index").to_string();
+pub async fn wiki(req: Request<()>) -> tide::Result {
+	let sub = req.param("sub").unwrap_or("reddit.com").to_string();
+	let page = req.param("page").unwrap_or("index").to_string();
 	let path: String = format!("/r/{}/wiki/{}.json?raw_json=1", sub, page);

 	match request(path).await {
-		Ok(res) => {
-			let s = WikiTemplate {
+		Ok(response) => template(WikiTemplate {
 			sub,
-				wiki: rewrite_url(res["data"]["content_html"].as_str().unwrap_or_default()),
+			wiki: rewrite_urls(response["data"]["content_html"].as_str().unwrap_or_default()),
 			page,
-				prefs: prefs(req),
-			}
-			.render()
-			.unwrap();
-			HttpResponse::Ok().content_type("text/html").body(s)
-		}
-		Err(msg) => error(msg).await,
+			prefs: Preferences::new(req),
+		}),
+		Err(msg) => error(req, msg).await,
 	}
 }

@ -167,11 +168,11 @@ async fn subreddit(sub: &str) -> Result<Subreddit, String> {
 			let icon = if community_icon.is_empty() { val(&res, "icon_img") } else { community_icon.to_string() };

 			let sub = Subreddit {
-				name: val(&res, "display_name"),
-				title: val(&res, "title"),
-				description: val(&res, "public_description"),
-				info: rewrite_url(&val(&res, "description_html").replace("\\", "")),
-				icon: format_url(icon.as_str()),
+				name: esc!(&res, "display_name"),
+				title: esc!(&res, "title"),
+				description: esc!(&res, "public_description"),
+				info: rewrite_urls(&val(&res, "description_html").replace("\\", "")),
+				icon: format_url(&icon),
 				members: format_num(members),
 				active: format_num(active),
 				wiki: res["data"]["wiki_enabled"].as_bool().unwrap_or_default(),
--- a/src/user.rs
+++ b/src/user.rs
@ -1,7 +1,8 @@
 // CRATES
-use crate::utils::{error, fetch_posts, format_url, param, prefs, request, Post, Preferences, User};
-use actix_web::{HttpRequest, HttpResponse, Result};
+use crate::esc;
+use crate::utils::{error, format_url, param, request, template, Post, Preferences, User};
 use askama::Template;
+use tide::Request;
 use time::OffsetDateTime;

 // STRUCTS
@ -16,42 +17,39 @@ struct UserTemplate {
 }

 // FUNCTIONS
-pub async fn profile(req: HttpRequest) -> HttpResponse {
+pub async fn profile(req: Request<()>) -> tide::Result {
 	// Build the Reddit JSON API path
-	let path = format!("{}.json?{}&raw_json=1", req.path(), req.query_string());
+	let path = format!("{}.json?{}&raw_json=1", req.url().path(), req.url().query().unwrap_or_default());

 	// Retrieve other variables from Libreddit request
 	let sort = param(&path, "sort");
-	let username = req.match_info().get("username").unwrap_or("").to_string();
+	let username = req.param("name").unwrap_or("").to_string();

 	// Request user posts/comments from Reddit
-	let posts = fetch_posts(&path, "Comment".to_string()).await;
+	let posts = Post::fetch(&path, "Comment".to_string()).await;

 	match posts {
 		Ok((posts, after)) => {
 			// If you can get user posts, also request user data
 			let user = user(&username).await.unwrap_or_default();

-			let s = UserTemplate {
+			template(UserTemplate {
 				user,
 				posts,
 				sort: (sort, param(&path, "t")),
 				ends: (param(&path, "after"), after),
-				prefs: prefs(req),
-			}
-			.render()
-			.unwrap();
-			HttpResponse::Ok().content_type("text/html").body(s)
+				prefs: Preferences::new(req),
+			})
 		}
 		// If there is an error show error page
-		Err(msg) => error(msg).await,
+		Err(msg) => error(req, msg).await,
 	}
 }

 // USER
 async fn user(name: &str) -> Result<User, String> {
 	// Build the Reddit JSON API path
-	let path: String = format!("/user/{}/about.json", name);
+	let path: String = format!("/user/{}/about.json?raw_json=1", name);

 	// Send a request to the url
 	match request(path).await {
@ -60,17 +58,17 @@ async fn user(name: &str) -> Result<User, String> {
 			// Grab creation date as unix timestamp
 			let created: i64 = res["data"]["created"].as_f64().unwrap_or(0.0).round() as i64;

-			// nested_val function used to parse JSON from Reddit APIs
+			// Closure used to parse JSON from Reddit APIs
 			let about = |item| res["data"]["subreddit"][item].as_str().unwrap_or_default().to_string();

 			// Parse the JSON output into a User struct
 			Ok(User {
 				name: name.to_string(),
-				title: about("title"),
-				icon: format_url(about("icon_img").as_str()),
+				title: esc!(about("title")),
+				icon: format_url(&about("icon_img")),
 				karma: res["data"]["total_karma"].as_i64().unwrap_or(0),
 				created: OffsetDateTime::from_unix_timestamp(created).format("%b %d '%y"),
-				banner: about("banner_img"),
+				banner: esc!(about("banner_img")),
 				description: about("public_description"),
 			})
 		}
--- a/src/utils.rs
+++ b/src/utils.rs
@ -1,23 +1,22 @@
 //
 // CRATES
 //
-use actix_web::{cookie::Cookie, HttpRequest, HttpResponse, Result};
+use crate::esc;
 use askama::Template;
-use base64::encode;
+use async_recursion::async_recursion;
+use async_std::{io, net::TcpStream, prelude::*};
+use async_tls::TlsConnector;
+use cached::proc_macro::cached;
 use regex::Regex;
-use serde_json::{from_str, Value};
+use serde_json::{from_str, Error, Value};
 use std::collections::HashMap;
+use tide::{http::url::Url, http::Cookie, Request, Response};
 use time::{Duration, OffsetDateTime};
-use url::Url;
-// use cached::proc_macro::cached;
-
-//
-// STRUCTS
-//

 // Post flair with content, background color and foreground color
 pub struct Flair {
 	pub flair_parts: Vec<FlairPart>,
+	pub text: String,
 	pub background_color: String,
 	pub foreground_color: String,
 }
@ -28,6 +27,42 @@ pub struct FlairPart {
 	pub value: String,
 }

+impl FlairPart {
+	pub fn parse(flair_type: &str, rich_flair: Option<&Vec<Value>>, text_flair: Option<&str>) -> Vec<Self> {
+		// Parse type of flair
+		match flair_type {
+			// If flair contains emojis and text
+			"richtext" => match rich_flair {
+				Some(rich) => rich
+					.iter()
+					// For each part of the flair, extract text and emojis
+					.map(|part| {
+						let value = |name: &str| part[name].as_str().unwrap_or_default();
+						Self {
+							flair_part_type: value("e").to_string(),
+							value: match value("e") {
+								"text" => value("t").to_string(),
+								"emoji" => format_url(value("u")),
+								_ => String::new(),
+							},
+						}
+					})
+					.collect::<Vec<Self>>(),
+				None => Vec::new(),
+			},
+			// If flair contains only text
+			"text" => match text_flair {
+				Some(text) => vec![Self {
+					flair_part_type: "text".to_string(),
+					value: text.to_string(),
+				}],
+				None => Vec::new(),
+			},
+			_ => Vec::new(),
+		}
+	}
+}
+
 pub struct Author {
 	pub name: String,
 	pub flair: Flair,
@ -44,6 +79,100 @@ pub struct Media {
 	pub url: String,
 	pub width: i64,
 	pub height: i64,
+	pub poster: String,
+}
+
+impl Media {
+	pub async fn parse(data: &Value) -> (String, Self, Vec<GalleryMedia>) {
+		let mut gallery = Vec::new();
+
+		// If post is a video, return the video
+		let (post_type, url_val) = if data["preview"]["reddit_video_preview"]["fallback_url"].is_string() {
+			// Return reddit video
+			("video", &data["preview"]["reddit_video_preview"]["fallback_url"])
+		} else if data["secure_media"]["reddit_video"]["fallback_url"].is_string() {
+			// Return reddit video
+			("video", &data["secure_media"]["reddit_video"]["fallback_url"])
+		} else if data["post_hint"].as_str().unwrap_or("") == "image" {
+			// Handle images, whether GIFs or pics
+			let preview = &data["preview"]["images"][0];
+			let mp4 = &preview["variants"]["mp4"];
+
+			if mp4.is_object() {
+				// Return the mp4 if the media is a gif
+				("gif", &mp4["source"]["url"])
+			} else {
+				// Return the picture if the media is an image
+				if data["domain"] == "i.redd.it" {
+					("image", &data["url"])
+				} else {
+					("image", &preview["source"]["url"])
+				}
+			}
+		} else if data["is_self"].as_bool().unwrap_or_default() {
+			// If type is self, return permalink
+			("self", &data["permalink"])
+		} else if data["is_gallery"].as_bool().unwrap_or_default() {
+			// If this post contains a gallery of images
+			gallery = GalleryMedia::parse(&data["gallery_data"]["items"], &data["media_metadata"]);
+
+			("gallery", &data["url"])
+		} else {
+			// If type can't be determined, return url
+			("link", &data["url"])
+		};
+
+		let source = &data["preview"]["images"][0]["source"];
+
+		let url = if post_type == "self" || post_type == "link" {
+			url_val.as_str().unwrap_or_default().to_string()
+		} else {
+			format_url(url_val.as_str().unwrap_or_default())
+		};
+
+		(
+			post_type.to_string(),
+			Self {
+				url,
+				width: source["width"].as_i64().unwrap_or_default(),
+				height: source["height"].as_i64().unwrap_or_default(),
+				poster: format_url(source["url"].as_str().unwrap_or_default()),
+			},
+			gallery,
+		)
+	}
+}
+
+pub struct GalleryMedia {
+	pub url: String,
+	pub width: i64,
+	pub height: i64,
+	pub caption: String,
+	pub outbound_url: String,
+}
+
+impl GalleryMedia {
+	fn parse(items: &Value, metadata: &Value) -> Vec<Self> {
+		items
+			.as_array()
+			.unwrap_or(&Vec::new())
+			.iter()
+			.map(|item| {
+				// For each image in gallery
+				let media_id = item["media_id"].as_str().unwrap_or_default();
+				let image = &metadata[media_id]["s"];
+
+				// Construct gallery items
+				Self {
+					url: format_url(image["u"].as_str().unwrap_or_default()),
+					width: image["x"].as_i64().unwrap_or_default(),
+					height: image["y"].as_i64().unwrap_or_default(),
+					caption: item["caption"].as_str().unwrap_or_default().to_string(),
+					outbound_url: item["outbound_url"].as_str().unwrap_or_default().to_string(),
+				}
+			})
+			.collect::<Vec<Self>>()
+	}
 }

 // Post containing content, metadata and media
@ -65,17 +194,134 @@ pub struct Post {
 	pub rel_time: String,
 	pub created: String,
 	pub comments: String,
+	pub gallery: Vec<GalleryMedia>,
 }

+impl Post {
+	// Fetch posts of a user or subreddit and return a vector of posts and the "after" value
+	pub async fn fetch(path: &str, fallback_title: String) -> Result<(Vec<Self>, String), String> {
+		let res;
+		let post_list;
+
+		// Send a request to the url
+		match request(path.to_string()).await {
+			// If success, receive JSON in response
+			Ok(response) => {
+				res = response;
+			}
+			// If the Reddit API returns an error, exit this function
+			Err(msg) => return Err(msg),
+		}
+
+		// Fetch the list of posts from the JSON response
+		match res["data"]["children"].as_array() {
+			Some(list) => post_list = list,
+			None => return Err("No posts found".to_string()),
+		}
+
+		let mut posts: Vec<Self> = Vec::new();
+
+		// For each post from posts list
+		for post in post_list {
+			let data = &post["data"];
+
+			let (rel_time, created) = time(data["created_utc"].as_f64().unwrap_or_default());
+			let score = data["score"].as_i64().unwrap_or_default();
+			let ratio: f64 = data["upvote_ratio"].as_f64().unwrap_or(1.0) * 100.0;
+			let title = esc!(post, "title");
+
+			// Determine the type of media along with the media URL
+			let (post_type, media, gallery) = Media::parse(&data).await;
+
+			posts.push(Self {
+				id: val(post, "id"),
+				title: esc!(if title.is_empty() { fallback_title.to_owned() } else { title }),
+				community: val(post, "subreddit"),
+				body: rewrite_urls(&val(post, "body_html")),
+				author: Author {
+					name: val(post, "author"),
+					flair: Flair {
+						flair_parts: FlairPart::parse(
+							data["author_flair_type"].as_str().unwrap_or_default(),
+							data["author_flair_richtext"].as_array(),
+							data["author_flair_text"].as_str(),
+						),
+						text: esc!(post, "link_flair_text"),
+						background_color: val(post, "author_flair_background_color"),
+						foreground_color: val(post, "author_flair_text_color"),
+					},
+					distinguished: val(post, "distinguished"),
+				},
+				score: if data["hide_score"].as_bool().unwrap_or_default() {
+					"\u{2022}".to_string()
+				} else {
+					format_num(score)
+				},
+				upvote_ratio: ratio as i64,
+				post_type,
+				thumbnail: Media {
+					url: format_url(val(post, "thumbnail").as_str()),
+					width: data["thumbnail_width"].as_i64().unwrap_or_default(),
+					height: data["thumbnail_height"].as_i64().unwrap_or_default(),
+					poster: "".to_string(),
+				},
+				media,
+				domain: val(post, "domain"),
+				flair: Flair {
+					flair_parts: FlairPart::parse(
+						data["link_flair_type"].as_str().unwrap_or_default(),
+						data["link_flair_richtext"].as_array(),
+						data["link_flair_text"].as_str(),
+					),
+					text: esc!(post, "link_flair_text"),
+					background_color: val(post, "link_flair_background_color"),
+					foreground_color: if val(post, "link_flair_text_color") == "dark" {
+						"black".to_string()
+					} else {
+						"white".to_string()
+					},
+				},
+				flags: Flags {
+					nsfw: data["over_18"].as_bool().unwrap_or_default(),
+					stickied: data["stickied"].as_bool().unwrap_or_default(),
+				},
+				permalink: val(post, "permalink"),
+				rel_time,
+				created,
+				comments: format_num(data["num_comments"].as_i64().unwrap_or_default()),
+				gallery,
+			});
+		}
+
+		Ok((posts, res["data"]["after"].as_str().unwrap_or_default().to_string()))
+	}
+}
+
+#[derive(Template)]
+#[template(path = "comment.html", escape = "none")]
 // Comment with content, post, score and data/time that it was posted
 pub struct Comment {
 	pub id: String,
+	pub kind: String,
+	pub parent_id: String,
+	pub parent_kind: String,
+	pub post_link: String,
+	pub post_author: String,
 	pub body: String,
 	pub author: Author,
 	pub score: String,
 	pub rel_time: String,
 	pub created: String,
+	pub edited: (String, String),
 	pub replies: Vec<Comment>,
+	pub highlighted: bool,
+}
+
+#[derive(Template)]
+#[template(path = "error.html", escape = "none")]
+pub struct ErrorTemplate {
+	pub msg: String,
+	pub prefs: Preferences,
 }

 #[derive(Default)]
@ -113,14 +359,6 @@ pub struct Params {
 	pub before: Option<String>,
 }

-// Error template
-#[derive(Template)]
-#[template(path = "error.html", escape = "none")]
-pub struct ErrorTemplate {
-	pub msg: String,
-	pub prefs: Preferences,
-}
-
 #[derive(Default)]
 pub struct Preferences {
 	pub theme: String,
@ -129,27 +367,29 @@ pub struct Preferences {
 	pub wide: String,
 	pub show_nsfw: String,
 	pub comment_sort: String,
-	pub subs: Vec<String>,
+	pub subscriptions: Vec<String>,
 }

-//
-// FORMATTING
-//
-
-// Build preferences from cookies
-pub fn prefs(req: HttpRequest) -> Preferences {
-	Preferences {
+impl Preferences {
+	// Build preferences from cookies
+	pub fn new(req: Request<()>) -> Self {
+		Self {
 			theme: cookie(&req, "theme"),
 			front_page: cookie(&req, "front_page"),
 			layout: cookie(&req, "layout"),
 			wide: cookie(&req, "wide"),
 			show_nsfw: cookie(&req, "show_nsfw"),
 			comment_sort: cookie(&req, "comment_sort"),
-		subs: cookie(&req, "subscriptions").split('+').map(String::from).filter(|s| !s.is_empty()).collect(),
+			subscriptions: cookie(&req, "subscriptions").split('+').map(String::from).filter(|s| !s.is_empty()).collect(),
+		}
 	}
 }

-// Grab a query param from a url
+//
+// FORMATTING
+//
+
+// Grab a query parameter from a url
 pub fn param(path: &str, value: &str) -> String {
 	match Url::parse(format!("https://libredd.it/{}", path).as_str()) {
 		Ok(url) => url.query_pairs().into_owned().collect::<HashMap<_, _>>().get(value).unwrap_or(&String::new()).to_owned(),
@ -157,9 +397,10 @@ pub fn param(path: &str, value: &str) -> String {
 	}
 }

-// Parse Cookie value from request
-pub fn cookie(req: &HttpRequest, name: &str) -> String {
-	actix_web::HttpMessage::cookie(req, name).unwrap_or_else(|| Cookie::new(name, "")).value().to_string()
+// Parse a cookie value from request
+pub fn cookie(req: &Request<()>, name: &str) -> String {
+	let cookie = req.cookie(name).unwrap_or_else(|| Cookie::named(name));
+	cookie.value().to_string()
 }

 // Direct urls to proxy if proxy is enabled
@ -167,14 +408,47 @@ pub fn format_url(url: &str) -> String {
 	if url.is_empty() || url == "self" || url == "default" || url == "nsfw" || url == "spoiler" {
 		String::new()
 	} else {
-		format!("/proxy/{}", encode(url).as_str())
+		match Url::parse(url) {
+			Ok(parsed) => {
+				let domain = parsed.domain().unwrap_or_default();
+
+				let capture = |regex: &str, format: &str, segments: i16| {
+					Regex::new(regex)
+						.map(|re| match re.captures(url) {
+							Some(caps) => match segments {
+								1 => [format, &caps[1], "/"].join(""),
+								2 => [format, &caps[1], "/", &caps[2], "/"].join(""),
+								_ => String::new(),
+							},
+							None => String::new(),
+						})
+						.unwrap_or_default()
+				};
+
+				match domain {
+					"v.redd.it" => capture(r"https://v\.redd\.it/(.*)/DASH_([0-9]{2,4}(\.mp4|$))", "/vid/", 2),
+					"i.redd.it" => capture(r"https://i\.redd\.it/(.*)", "/img/", 1),
+					"a.thumbs.redditmedia.com" => capture(r"https://a\.thumbs\.redditmedia\.com/(.*)", "/thumb/a/", 1),
+					"b.thumbs.redditmedia.com" => capture(r"https://b\.thumbs\.redditmedia\.com/(.*)", "/thumb/b/", 1),
+					"emoji.redditmedia.com" => capture(r"https://emoji\.redditmedia\.com/(.*)/(.*)", "/emoji/", 2),
+					"preview.redd.it" => capture(r"https://preview\.redd\.it/(.*)\?(.*)", "/preview/pre/", 2),
+					"external-preview.redd.it" => capture(r"https://external\-preview\.redd\.it/(.*)\?(.*)", "/preview/external-pre/", 2),
+					"styles.redditmedia.com" => capture(r"https://styles\.redditmedia\.com/(.*)", "/style/", 1),
+					"www.redditstatic.com" => capture(r"https://www\.redditstatic\.com/(.*)", "/static/", 1),
+					_ => String::new(),
+				}
+			}
+			Err(_) => String::new(),
+		}
 	}
 }

 // Rewrite Reddit links to Libreddit in body of text
-pub fn rewrite_url(text: &str) -> String {
-	let re = Regex::new(r#"href="(https://|http://|)(www.|)(reddit).(com)/"#).unwrap();
-	re.replace_all(text, r#"href="/"#).to_string()
+pub fn rewrite_urls(text: &str) -> String {
+	match Regex::new(r#"href="(https|http|)://(www.|old.|np.|)(reddit).(com)/"#) {
+		Ok(re) => re.replace_all(text, r#"href="/"#).to_string(),
+		Err(_) => String::new(),
+	}
 }

 // Append `m` and `k` for millions and thousands respectively
@ -188,82 +462,7 @@ pub fn format_num(num: i64) -> String {
 	}
 }

-pub async fn media(data: &Value) -> (String, Media) {
-	let post_type: &str;
-	// If post is a video, return the video
-	let url = if data["preview"]["reddit_video_preview"]["fallback_url"].is_string() {
-		post_type = "video";
-		format_url(data["preview"]["reddit_video_preview"]["fallback_url"].as_str().unwrap_or_default())
-	} else if data["secure_media"]["reddit_video"]["fallback_url"].is_string() {
-		post_type = "video";
-		format_url(data["secure_media"]["reddit_video"]["fallback_url"].as_str().unwrap_or_default())
-	// Handle images, whether GIFs or pics
-	} else if data["post_hint"].as_str().unwrap_or("") == "image" {
-		let preview = data["preview"]["images"][0].clone();
-		match preview["variants"]["mp4"].as_object() {
-			// Return the mp4 if the media is a gif
-			Some(gif) => {
-				post_type = "gif";
-				format_url(gif["source"]["url"].as_str().unwrap_or_default())
-			}
-			// Return the picture if the media is an image
-			None => {
-				post_type = "image";
-				format_url(preview["source"]["url"].as_str().unwrap_or_default())
-			}
-		}
-	} else if data["is_self"].as_bool().unwrap_or_default() {
-		post_type = "self";
-		data["permalink"].as_str().unwrap_or_default().to_string()
-	} else {
-		post_type = "link";
-		data["url"].as_str().unwrap_or_default().to_string()
-	};
-
-	(
-		post_type.to_string(),
-		Media {
-			url,
-			width: data["preview"]["images"][0]["source"]["width"].as_i64().unwrap_or_default(),
-			height: data["preview"]["images"][0]["source"]["height"].as_i64().unwrap_or_default(),
-		},
-	)
-}
-
-pub fn parse_rich_flair(flair_type: String, rich_flair: Option<&Vec<Value>>, text_flair: Option<&str>) -> Vec<FlairPart> {
-	// Parse type of flair
-	match flair_type.as_str() {
-		// If flair contains emojis and text
-		"richtext" => match rich_flair {
-			Some(rich) => rich
-				.iter()
-				// For each part of the flair, extract text and emojis
-				.map(|part| {
-					let value = |name: &str| part[name].as_str().unwrap_or_default();
-					FlairPart {
-						flair_part_type: value("e").to_string(),
-						value: match value("e") {
-							"text" => value("t").to_string(),
-							"emoji" => format_url(value("u")),
-							_ => String::new(),
-						},
-					}
-				})
-				.collect::<Vec<FlairPart>>(),
-			None => Vec::new(),
-		},
-		// If flair contains only text
-		"text" => match text_flair {
-			Some(text) => vec![FlairPart {
-				flair_part_type: "text".to_string(),
-				value: text.to_string(),
-			}],
-			None => Vec::new(),
-		},
-		_ => Vec::new(),
-	}
-}
-
+// Parse a relative and absolute time from a UNIX timestamp
 pub fn time(created: f64) -> (String, String) {
 	let time = OffsetDateTime::from_unix_timestamp(created.round() as i64);
 	let time_delta = OffsetDateTime::now_utc() - time;
@ -280,210 +479,146 @@ pub fn time(created: f64) -> (String, String) {
 		format!("{}m ago", time_delta.whole_minutes())
 	};

-	(rel_time, time.format("%b %d %Y, %H:%M UTC"))
+	(rel_time, time.format("%b %d %Y, %H:%M:%S UTC"))
 }

-//
-// JSON PARSING
-//
-
 // val() function used to parse JSON from Reddit APIs
 pub fn val(j: &Value, k: &str) -> String {
 	j["data"][k].as_str().unwrap_or_default().to_string()
 }

-// Fetch posts of a user or subreddit and return a vector of posts and the "after" value
-pub async fn fetch_posts(path: &str, fallback_title: String) -> Result<(Vec<Post>, String), String> {
-	let res;
-	let post_list;
-
-	// Send a request to the url
-	match request(path.to_string()).await {
-		// If success, receive JSON in response
-		Ok(response) => {
-			res = response;
-		}
-		// If the Reddit API returns an error, exit this function
-		Err(msg) => return Err(msg),
-	}
-
-	// Fetch the list of posts from the JSON response
-	match res["data"]["children"].as_array() {
-		Some(list) => post_list = list,
-		None => return Err("No posts found".to_string()),
-	}
-
-	let mut posts: Vec<Post> = Vec::new();
-
-	// For each post from posts list
-	for post in post_list {
-		let (rel_time, created) = time(post["data"]["created_utc"].as_f64().unwrap_or_default());
-		let score = post["data"]["score"].as_i64().unwrap_or_default();
-		let ratio: f64 = post["data"]["upvote_ratio"].as_f64().unwrap_or(1.0) * 100.0;
-		let title = val(post, "title");
-
-		// Determine the type of media along with the media URL
-		let (post_type, media) = media(&post["data"]).await;
-
-		posts.push(Post {
-			id: val(post, "id"),
-			title: if title.is_empty() { fallback_title.to_owned() } else { title },
-			community: val(post, "subreddit"),
-			body: rewrite_url(&val(post, "body_html")),
-			author: Author {
-				name: val(post, "author"),
-				flair: Flair {
-					flair_parts: parse_rich_flair(
-						val(post, "author_flair_type"),
-						post["data"]["author_flair_richtext"].as_array(),
-						post["data"]["author_flair_text"].as_str(),
-					),
-					background_color: val(post, "author_flair_background_color"),
-					foreground_color: val(post, "author_flair_text_color"),
-				},
-				distinguished: val(post, "distinguished"),
-			},
-			score: if post["data"]["hide_score"].as_bool().unwrap_or_default() {
-				"•".to_string()
-			} else {
-				format_num(score)
-			},
-			upvote_ratio: ratio as i64,
-			post_type,
-			thumbnail: Media {
-				url: format_url(val(post, "thumbnail").as_str()),
-				width: post["data"]["thumbnail_width"].as_i64().unwrap_or_default(),
-				height: post["data"]["thumbnail_height"].as_i64().unwrap_or_default(),
-			},
-			media,
-			domain: val(post, "domain"),
-			flair: Flair {
-				flair_parts: parse_rich_flair(
-					val(post, "link_flair_type"),
-					post["data"]["link_flair_richtext"].as_array(),
-					post["data"]["link_flair_text"].as_str(),
-				),
-				background_color: val(post, "link_flair_background_color"),
-				foreground_color: if val(post, "link_flair_text_color") == "dark" {
-					"black".to_string()
-				} else {
-					"white".to_string()
-				},
-			},
-			flags: Flags {
-				nsfw: post["data"]["over_18"].as_bool().unwrap_or_default(),
-				stickied: post["data"]["stickied"].as_bool().unwrap_or_default(),
-			},
-			permalink: val(post, "permalink"),
-			rel_time,
-			created,
-			comments: format_num(post["data"]["num_comments"].as_i64().unwrap_or_default()),
-		});
-	}
-
-	Ok((posts, res["data"]["after"].as_str().unwrap_or_default().to_string()))
+#[macro_export]
+macro_rules! esc {
+	($f:expr) => {
+		$f.replace('<', "&lt;").replace('>', "&gt;")
+	};
+	($j:expr, $k:expr) => {
+		$j["data"][$k].as_str().unwrap_or_default().to_string().replace('<', "&lt;").replace('>', "&gt;")
+	};
 }

+// Escape < and > to accurately render HTML
+// pub fn esc(j: &Value, k: &str) -> String {
+// 	val(j,k)
+// 		// .replace('&', "&amp;")
+// 		.replace('<', "&lt;")
+// 		.replace('>', "&gt;")
+// 		// .replace('"', "&quot;")
+// 		// .replace('\'', "&#x27;")
+// 		// .replace('/', "&#x2f;")
+// }
+
 //
 // NETWORKING
 //

-pub async fn error(msg: String) -> HttpResponse {
+pub fn template(t: impl Template) -> tide::Result {
+	Ok(Response::builder(200).content_type("text/html").body(t.render().unwrap_or_default()).build())
+}
+
+pub fn redirect(path: String) -> Response {
+	Response::builder(302)
+		.content_type("text/html")
+		.header("Location", &path)
+		.body(format!("Redirecting to <a href=\"{0}\">{0}</a>...", path))
+		.build()
+}
+
+pub async fn error(req: Request<()>, msg: String) -> tide::Result {
 	let body = ErrorTemplate {
 		msg,
-		prefs: Preferences::default(),
+		prefs: Preferences::new(req),
 	}
 	.render()
 	.unwrap_or_default();
-	HttpResponse::NotFound().content_type("text/html").body(body)
+
+	Ok(Response::builder(404).content_type("text/html").body(body).build())
+}
+
+#[async_recursion]
+async fn connect(path: String) -> io::Result<String> {
+	// Build reddit-compliant user agent for Libreddit
+	let user_agent = format!("web:libreddit:{}", env!("CARGO_PKG_VERSION"));
+
+	// Construct an HTTP request body
+	let req = format!(
+		"GET {} HTTP/1.1\r\nHost: www.reddit.com\r\nAccept: */*\r\nConnection: close\r\nUser-Agent: {}\r\n\r\n",
+		path, user_agent
+	);
+
+	// Open a TCP connection
+	let tcp_stream = TcpStream::connect("www.reddit.com:443").await?;
+
+	// Initialize TLS connector for requests
+	let connector = TlsConnector::default();
+
+	// Use the connector to start the handshake process
+	let mut tls_stream = connector.connect("www.reddit.com", tcp_stream).await?;
+
+	// Write the crafted HTTP request to the stream
+	tls_stream.write_all(req.as_bytes()).await?;
+
+	// And read the response
+	let mut writer = Vec::new();
+	io::copy(&mut tls_stream, &mut writer).await?;
+	let response = String::from_utf8_lossy(&writer).to_string();
+
+	let split = response.split("\r\n\r\n").collect::<Vec<&str>>();
+
+	let headers = split[0].split("\r\n").collect::<Vec<&str>>();
+	let status: i16 = headers[0].split(' ').collect::<Vec<&str>>()[1].parse().unwrap_or(200);
+	let body = split[1].to_string();
+
+	if (300..400).contains(&status) {
+		let location = headers
+			.iter()
+			.find(|header| header.starts_with("location:"))
+			.map(|f| f.to_owned())
+			.unwrap_or_default()
+			.split(": ")
+			.collect::<Vec<&str>>()[1];
+		connect(location.replace("https://www.reddit.com", "")).await
+	} else {
+		Ok(body)
+	}
 }

 // Make a request to a Reddit API and parse the JSON response
-// #[cached(size=100,time=60, result = true)]
+#[cached(size = 100, time = 30, result = true)]
 pub async fn request(path: String) -> Result<Value, String> {
 	let url = format!("https://www.reddit.com{}", path);
-	let user_agent = format!("web:libreddit:{}", env!("CARGO_PKG_VERSION"));

-	// Send request using awc
-	// async fn send(url: &str) -> Result<String, (bool, String)> {
-	// 	let client = actix_web::client::Client::default();
-	// 	let response = client.get(url).header("User-Agent", format!("web:libreddit:{}", env!("CARGO_PKG_VERSION"))).send().await;
+	let err = |msg: &str, e: String| -> Result<Value, String> {
+		eprintln!("{} - {}: {}", url, msg, e);
+		Err(msg.to_string())
+	};

-	// 	match response {
-	// 		Ok(mut payload) => {
-	// 			// Get first number of response HTTP status code
-	// 			match payload.status().to_string().chars().next() {
-	// 				// If success
-	// 				Some('2') => Ok(String::from_utf8(payload.body().limit(20_000_000).await.unwrap_or_default().to_vec()).unwrap_or_default()),
-	// 				// If redirection
-	// 				Some('3') => match payload.headers().get("location") {
-	// 					Some(location) => Err((true, location.to_str().unwrap_or_default().to_string())),
-	// 					None => Err((false, "Page not found".to_string())),
-	// 				},
-	// 				// Otherwise
-	// 				_ => Err((false, "Page not found".to_string())),
-	// 			}
-	// 		}
-	// 		Err(e) => { dbg!(e); Err((false, "Couldn't send request to Reddit, this instance may be being rate-limited. Try another.".to_string())) },
-	// 	}
-	// }
-
-	// // Print error if debugging then return error based on error message
-	// fn err(url: String, msg: String) -> Result<Value, String> {
-	// 	// #[cfg(debug_assertions)]
-	// 	dbg!(format!("{} - {}", url, msg));
-	// 	Err(msg)
-	// };
-
-	// // Parse JSON from body. If parsing fails, return error
-	// fn json(url: String, body: String) -> Result<Value, String> {
-	// 	match from_str(body.as_str()) {
-	// 		Ok(json) => Ok(json),
-	// 		Err(_) => err(url, "Failed to parse page JSON data".to_string()),
-	// 	}
-	// }
-
-	// // Make request to Reddit using send function
-	// match send(&url).await {
-	// 	// If success, parse and return body
-	// 	Ok(body) => json(url, body),
-	// 	// Follow any redirects
-	// 	Err((true, location)) => match send(location.as_str()).await {
-	// 		// If success, parse and return body
-	// 		Ok(body) => json(url, body),
-	// 		// Follow any redirects again
-	// 		Err((true, location)) => err(url, location),
-	// 		// Return errors if request fails
-	// 		Err((_, msg)) => err(url, msg),
-	// 	},
-	// 	// Return errors if request fails
-	// 	Err((_, msg)) => err(url, msg),
-	// }
-
-	// Send request using ureq
-	match ureq::get(&url).set("User-Agent", user_agent.as_str()).call() {
-		// If response is success
-		Ok(response) => {
+	match connect(path).await {
+		Ok(body) => {
 			// Parse the response from Reddit as JSON
-			let json_string = &response.into_string().unwrap_or_default();
-			match from_str(json_string) {
-				Ok(json) => Ok(json),
-				Err(e) => {
-					println!("{} - Failed to parse page JSON data: {} - {}", url, e, json_string);
-					Err("Failed to parse page JSON data".to_string())
+			let parsed: Result<Value, Error> = from_str(&body);
+			match parsed {
+				Ok(json) => {
+					// If Reddit returned an error
+					if json["error"].is_i64() {
+						Err(
+							json["reason"]
+								.as_str()
+								.unwrap_or_else(|| {
+									json["message"].as_str().unwrap_or_else(|| {
+										eprintln!("{} - Error parsing reddit error", url);
+										"Error parsing reddit error"
+									})
+								})
+								.to_string(),
+						)
+					} else {
+						Ok(json)
 					}
 				}
+				Err(e) => err("Failed to parse page JSON data", e.to_string()),
 			}
-		// If response is error
-		Err(ureq::Error::Status(_, _)) => {
-			#[cfg(debug_assertions)]
-			dbg!(format!("{} - Page not found", url));
-			Err("Page not found".to_string())
-		}
-		// If failed to send request
-		Err(e) => {
-			println!("{} - Couldn't send request to Reddit: {}", url, e);
-			Err("Couldn't send request to Reddit, this instance may be being rate-limited. Try another.".to_string())
 		}
+		Err(e) => err("Couldn't send request to Reddit", e.to_string()),
 	}
 }
--- a/static/apple-touch-icon.png
+++ b/static/apple-touch-icon.png
--- a/static/favicon.ico
+++ b/static/favicon.ico
--- a/static/favicon.png
+++ b/static/favicon.png
--- a/static/logo.png
+++ b/static/logo.png
--- a/static/manifest.json
+++ b/static/manifest.json
@ -0,0 +1,23 @@
+{
+	"name": "Libreddit",
+	"short_name": "Libreddit",
+	"display": "standalone",
+	"background_color": "#1f1f1f",
+	"description": "An alternative private front-end to Reddit",
+	"theme_color": "#1f1f1f",
+	"icons": [
+		{
+			"src": "logo.png",
+			"sizes": "512x512",
+			"type": "image/png"
+		},
+		{
+			"src": "apple-touch-icon.png",
+			"sizes": "180x180"
+		},
+		{
+			"src": "favicon.ico",
+			"sizes": "32x32"
+		}
+	]
+}
--- a/static/style.css
+++ b/static/style.css
@ -51,6 +51,21 @@
 	--shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
 }

+/* Black theme setting */
+.black {
+	--accent: #009a9a;
+	--green: #00a229;
+	--text: white;
+	--foreground: #0f0f0f;
+	--background: black;
+	--outside: black;
+	--post: black;
+	--panel-border: 2px solid #0f0f0f;
+	--highlighted: #0f0f0f;
+	--shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+
 /* General */

 ::selection {
@ -58,6 +73,10 @@
 	background: var(--accent);
 }

+:focus-visible {
+	outline: 2px solid var(--accent);
+}
+
 html, body, div, h1, h2, h3, h4, h5, h6, ul, ol, dl, li, dt, dd, p, blockquote,
 pre, form, fieldset, table, th, td, select, input {
 	margin: 0;
@ -241,10 +260,11 @@ aside {
 }

 #user_description, #sub_description {
-	margin: 0 20px;
+	margin: 0 15px;
+	text-align: left;
 }

-#user_name, #user_description:not(:empty), #user_icon
+#user_name, #user_description:not(:empty), #user_icon,
 #sub_name, #sub_icon, #sub_description:not(:empty) {
 	margin-bottom: 20px;
 }
@ -265,6 +285,10 @@ aside {
 	margin-top: 20px;
 }

+#multisub {
+	margin-bottom: 20px;
+}
+
 .subscribe, .unsubscribe {
 	padding: 10px 20px;
 	border-radius: 5px;
@ -281,9 +305,9 @@ aside {
 	background-color: var(--highlighted);
 }

-/* Subscribed subreddit list */
+/* Feeds */

-#subscriptions {
+#feeds {
 	position: relative;
 	border-radius: 5px;
 	border: var(--panel-border);
@ -294,14 +318,15 @@ aside {
 	display: inline-block;
 }

-#subscriptions > summary {
+#feeds > summary {
 	padding: 8px 15px;
 }

-#sub_list {
+#feed_list {
 	position: absolute;
 	display: flex;
 	min-width: 100%;
+	max-height: 500px;
 	border-radius: 5px;
 	box-shadow: var(--shadow);
 	background: var(--outside);
@ -310,17 +335,24 @@ aside {
 	z-index: 1;
 }

-#sub_list > a {
+#feed_list > p {
+	font-size: 13px;
+	opacity: 0.5;
+	padding: 5px 20px;
+	margin-top: 10px;
+}
+
+#feed_list > a {
 	padding: 10px 20px;
 	transition: 0.2s background;
 }

-#sub_list > .selected {
+#feed_list > .selected {
 	background-color: var(--accent);
 	color: var(--foreground);
 }

-#sub_list > a:not(.selected):hover {
+#feed_list > a:not(.selected):hover {
 	background-color: var(--foreground);
 }

@ -528,6 +560,12 @@ a.search_subreddit:hover {
 	word-break: break-word;
 }

+.thread_nav {
+	color: var(--accent);
+	font-weight: bold;
+	margin: 10px 0;
+}
+
 .post {
 	border-radius: 5px;
 	background: var(--post);
@ -590,6 +628,10 @@ a.search_subreddit:hover {
 	font-weight: bold;
 }

+.author_flair, .post_flair:empty {
+	display: none;
+}
+
 .emoji {
 	width: 1em;
 	height: 1em;
@ -610,27 +652,61 @@ a.search_subreddit:hover {
 	font-weight: bold;
 }

-.post_media {
+.post_media_image, .post .__NoScript_PlaceHolder__, .post_media_video, .gallery  {
 	max-width: calc(100% - 40px);
-	height: auto;
-	align-self: center;
-	margin-top: 15px;
-	margin: 5px auto;
 	grid-area: post_media;
-	background-color: var(--highlighted);
-	background-image: url("data:image/svg+xml;utf8,<svg viewBox='0 0 100 100' width='100' height='100' xmlns='http://www.w3.org/2000/svg'><path d='M15,20 h70 a10,10 0 0 1 10,10 v45 a10,10 0 0 1 -10,10 h-70 a10,10 0 0 1 -10,-10 v-45 a10,10 0 0 1 10,-10 z' fill='none' stroke='rgba(128,128,128,0.5)' stroke-width='3' /><path d='M15,75 l25,-35 l15,20 l10,-10 l20, 25 z' stroke='none' fill='rgba(128,128,128,0.5)' /><circle cx='75' cy='35' r='7' stroke='none' fill='rgba(128,128,128,0.5)'/></svg>");
-	background-position: 50%;
-	background-repeat: no-repeat;
+	margin: 15px auto 5px auto;
+	height: auto;
 }

-.post_media.short {
+
+.post_media_video.short {
 	max-height: 512px;
 	width: auto;
 }

+.post_media_image.short svg, .post_media_image.short img{
+	max-height: 512px;
+	width: auto;
+}
+
+.post_media_image svg{
+	max-width: 100%;
+	height: auto;
+	align-self: center;
+	background-color: var(--highlighted);
+	background-image: url("data:image/svg+xml;utf8,<svg viewBox='0 0 100 100' width='100' height='100' xmlns='http://www.w3.org/2000/svg'><path d='M15,20 h70 a10,10 0 0 1 10,10 v45 a10,10 0 0 1 -10,10 h-70 a10,10 0 0 1 -10,-10 v-45 a10,10 0 0 1 10,-10 z' fill='none' stroke='rgba(128,128,128,0.5)' stroke-width='3' /><path d='M15,75 l25,-35 l15,20 l10,-10 l20, 25 z' stroke='none' fill='rgba(128,128,128,0.5)' /><circle cx='75' cy='35' r='7' stroke='none' fill='rgba(128,128,128,0.5)'/></svg>");
+	background-position: 50%;
+	background-repeat: no-repeat;
+	vertical-align: bottom;
+}
+
+.post_media_image img {
+	max-width: 100%;
+	vertical-align: bottom;
+}
+
+.gallery img {
+	max-width: 100%;
+	vertical-align: bottom;
+}
+
+.gallery figcaption {
+	margin-top: 5px;
+}
+
+.gallery .outbound_url {
+	color: var(--accent);
+	text-overflow: ellipsis;
+	overflow: hidden;
+	white-space: nowrap;
+	display: block;
+	padding-top: 5px;
+}
+
 #post_url {
 	color: var(--accent);
-	margin: 5px 20px;
+	margin: 5px 15px;
 	grid-area: post_media;
 }

@ -639,6 +715,7 @@ a.search_subreddit:hover {
 	font-weight: normal;
 	margin: 5px 15px;
 	grid-area: post_body;
+	width: calc(100% - 30px);
 }

 .post_footer {
@ -707,6 +784,10 @@ a.search_subreddit:hover {
 	align-self: end;
 }

+.post_thumbnail img {
+	max-width: 100%;	
+}
+
 .stickied {
 	--accent: var(--green);
 	border: 1px solid var(--green);
@ -779,7 +860,12 @@ a.search_subreddit:hover {
 .comment_body {
 	opacity: 0.9;
 	font-weight: normal;
-	margin: 10px 5px;
+	padding: 5px 5px;
+	margin: 5px 0;
+}
+
+.comment_body.highlighted {
+	background: var(--highlighted);
 }

 .comment_body > p:not(:first-child) {
@ -809,6 +895,12 @@ a.search_subreddit:hover {
 	opacity: 0.5;
 }

+.edited {
+	opacity: 0.4;
+	font-style: italic;
+	font-size: 14px;
+}
+
 .line {
 	width: 2px;
 	height: 100%;
@ -877,19 +969,21 @@ a.search_subreddit:hover {

 /* Settings */

-#settings, #settings > form {
-	display: flex;
-	flex-direction: column;
-	align-items: center;
+#settings {
+	max-width: 450px;
 }

 #settings_note {
 	font-size: 14px;
-	max-width: 300px;
 	margin-top: 10px;
 	opacity: 0.75;
 }

+#settings_note a {
+	color: var(--accent);
+}
+
+
 .prefs {
 	display: flex;
 	flex-direction: column;
@ -898,6 +992,7 @@ a.search_subreddit:hover {
 	padding: 20px;
 	background: var(--post);
 	border-radius: 5px;
+	margin-bottom: 20px;
 }

 .prefs > div {
@ -906,10 +1001,7 @@ a.search_subreddit:hover {
 	width: 100%;
 	height: 35px;
 	align-items: center;
-}
-
-.prefs > div:not(:last-of-type) {
-	margin-bottom: 10px;
+	margin-top: 10px;
 }

 .prefs select {
@ -936,28 +1028,16 @@ input[type="submit"] {
 	-moz-appearance: none;
 }

-#settings_subs {
-	list-style: none;
-	padding: 0;
-}
-
-#settings_subs > li {
-	display: flex;
-	margin: 10px 0;
-}
-#settings_subs > li:last-of-type { margin-bottom: 0; }
-
-#settings_subs > li > span {
-	padding: 10px 0;
-	margin-right: auto;
-}
-
 #settings_subs .unsubscribe {
 	margin-left: 30px;
 }

 /* Markdown */

+.md {
+	width: 100%;
+}
+
 .md > *:not(:first-child) {
 	margin-top: 20px;
 }
@ -1026,48 +1106,15 @@ td, th {
 	padding: 10px;
 }

+/* Errors */
+
+#error { text-align: center; }
+#error h1 { margin-bottom: 10px; }
+#error h3 { opacity: 0.85; }
+#error a { color: var(--accent); }
+
 /* Mobile */

-@media screen and (max-width: 480px) {
-	#version { display: none; }
-
-	.post {
-		grid-template: 	"post_header post_header post_thumbnail" auto
-				"post_title  post_title  post_thumbnail" 1fr
-				"post_media  post_media  post_thumbnail" auto
-				"post_body   post_body   post_thumbnail" auto
-				"post_score  post_footer post_thumbnail" auto
-				/ auto 1fr fit-content(min(20%, 152px));
-	}
-	
-	.post_score {
-		margin: 5px 0px 20px 15px;
-		padding: 0;
-	}
-	
-	.compact .post_score { padding: 0; }
-	
-	.post_score::before {	content: "↑" }
-
-	.post_header { font-size: 14px; }
-	.post_footer { margin-left: 15px;	}
-
-	.replies > .comment {
-		margin-left: -25px;
-		padding: 5px 0;
-	}
-
-	.comment_left {
-		min-width: 45px;
-		padding: 5px 0px;
-	}
-
-	.comment_author { margin-left: 10px; }
-	.comment_score { min-width: 35px;	}
-	.comment_data::marker { font-size: 18px; }
-	.created { width: 100%; }
-}
-
@media screen and (max-width: 800px) {
 	body { padding-top: 120px }

@ -1096,6 +1143,10 @@ td, th {
 		min-width: auto;
 	}
 	
+	#settings {
+		max-width: unset;
+	}
+
 	aside, #subreddit, #user {
 		margin: 0;
 		max-width: 100%;
@ -1105,3 +1156,60 @@ td, th {
 	#logo, #links { margin-bottom: 5px; }
 	#searchbox { width: calc(100vw - 35px); }
 }
+
+@media screen and (max-width: 480px) {
+	body { padding-top: 100px; }
+	#version { display: none; }
+
+	.post {
+		grid-template: 	"post_header post_header post_thumbnail" auto
+				"post_title  post_title  post_thumbnail" 1fr
+				"post_media  post_media  post_thumbnail" auto
+				"post_body   post_body   post_thumbnail" auto
+				"post_score  post_footer post_thumbnail" auto
+				/ auto 1fr fit-content(min(20%, 152px));
+	}
+	
+	.post_score {
+		margin: 5px 0px 20px 15px;
+		padding: 0;
+	}
+	
+	.compact .post_score { padding: 0; }
+	
+	.post_score::before {	content: "↑" }
+
+	.post_header { font-size: 14px; }
+	.post_footer { margin-left: 15px;	}
+
+	.replies > .comment {
+		margin-left: -12px;
+		padding: 5px 0;
+	}
+
+	.comment_left {
+		min-width: auto;
+		padding: 5px 0px;
+		align-items: initial;
+		margin-top: -5px;
+	}
+
+	.line {
+		margin-left: 5px;
+	}
+
+	/* .thread { margin-left: -5px; } */
+	.comment_right { padding: 5px 0 10px 2px; }
+	.comment_author { margin-left: 5px; }
+	.comment_data { margin-left: 12px; }
+	.comment_data::marker { font-size: 22px; }
+	.created { width: 100%; }
+
+	.comment_score {
+		min-width: 32px;
+		height: 20px;
+		font-size: 15px;
+		padding: 7px 0px;
+		margin-right: -5px;
+	}
+}
--- a/templates/base.html
+++ b/templates/base.html
@ -6,8 +6,20 @@
 		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
 		<meta name="description" content="View on Libreddit, an alternative private front-end to Reddit.">
 		<meta name="viewport" content="width=device-width, initial-scale=1.0">
-		<link rel="shortcut icon" type="image/x-icon" href="/favicon.ico"> 
-		<link rel="stylesheet" type="text/css" href="/style.css">
+		<!-- General PWA -->
+		<meta name="theme-color" content="#1F1F1F">
+		<!-- iOS Application -->
+		<meta name="apple-mobile-web-app-title" content="Libreddit">
+		<meta name="apple-mobile-web-app-capable" content="yes">
+		<meta name="apple-mobile-web-app-status-bar-style" content="default">
+		<!-- Android  -->
+		<meta name="mobile-web-app-capable" content="yes">
+		<!-- iOS Logo -->
+		<link href="/touch-icon-iphone.png/" rel="apple-touch-icon">
+		<!-- PWA Manifest -->
+		<link rel="manifest" type="application/json" href="/manifest.json/">
+		<link rel="shortcut icon" type="image/x-icon" href="/favicon.ico/"> 
+		<link rel="stylesheet" type="text/css" href="/style.css/">
 		{% endblock %}
 		</head>
 	<body class="
@ -17,21 +29,25 @@
 		<!-- NAVIGATION BAR -->
 		<nav>
 			<div id="logo">
-				<a id="libreddit" href="/">
-					<span id="lib">lib</span><span id="reddit">reddit.</span>
-				</a>
+				<a id="libreddit" href="/"><span id="lib">lib</span><span id="reddit">reddit.</span></a>
 				<span id="version">v{{ env!("CARGO_PKG_VERSION") }}</span>
 				{% block subscriptions %}{% endblock %}
 			</div>
 			{% block search %}{% endblock %}
 			<div id="links">
-				<a id="settings_link" href="/settings">
+				<a id="settings_link" href="/settings/">
 					<span>settings</span>
-					<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z"/></svg>
+					<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+						<title>settings</title>
+						<circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z"/>
+					</svg>
 				</a>
 				<a id="code" href="https://github.com/spikecodes/libreddit">
 					<span>code</span>
-					<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/></svg>
+					<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+						<title>code</title>
+						<polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/>
+					</svg>
 				</a>
 			</div>
 		</nav>
--- a/templates/comment.html
+++ b/templates/comment.html
@ -0,0 +1,25 @@
+{% import "utils.html" as utils %}
+
+{% if kind == "more" && parent_kind == "t1" %}
+<a class="deeper_replies" href="{{ post_link }}{{ parent_id }}">&rarr; More replies</a>
+{% else if kind == "t1"  %}
+<div id="{{ id }}" class="comment">
+	<div class="comment_left">
+		<p class="comment_score">{{ score }}</p>
+		<div class="line"></div>
+	</div>
+	<details class="comment_right" open>
+		<summary class="comment_data">
+			<a class="comment_author {{ author.distinguished }} {% if author.name == post_author %}op{% endif %}" href="/u/{{ author.name }}">u/{{ author.name }}</a>
+			{% if author.flair.flair_parts.len() > 0 %}
+				<small class="author_flair">{% call utils::render_flair(author.flair.flair_parts) %}</small>
+			{% endif %}
+			<a href="{{ post_link }}{{ id }}/?context=3" class="created" title="{{ created }}">{{ rel_time }}</a>
+			{% if edited.0 != "".to_string() %}<span class="edited" title="{{ edited.1 }}">edited {{ edited.0 }}</span>{% endif %}
+		</summary>
+		<div class="comment_body {% if highlighted %}highlighted{% endif %}">{{ body }}</div>
+		<blockquote class="replies">{% for c in replies -%}{{ c.render().unwrap() }}{%- endfor %}
+		</blockquote>
+	</details>
+</div>
+{% endif %}
--- a/templates/error.html
+++ b/templates/error.html
@ -2,5 +2,8 @@
 {% block title %}Error: {{ msg }}{% endblock %}
 {% block sortstyle %}{% endblock %}
 {% block content %}
-	<h1 style="text-align: center; font-size: 50px;">{{ msg }}</h1>
+	<div id="error">
+		<h1>{{ msg }}</h1>
+		<h3>Head back <a href="/">home</a>?</h3>
+	</div>
 {% endblock %}
--- a/templates/post.html
+++ b/templates/post.html
@ -10,36 +10,25 @@
 {% block root %}/r/{{ post.community }}{% endblock %}{% block location %}r/{{ post.community }}{% endblock %}
 {% block head %}
 	{% call super() %}
+	<!-- Meta Tags -->
 	<meta name="author" content="u/{{ post.author.name }}">
+	<meta name="title" content="{{ post.title }} - r/{{ post.community }}">
+	<meta property="og:type" content="website">
+	<meta property="og:url" content="{{ post.permalink }}">
+	<meta property="og:title" content="{{ post.title }} - r/{{ post.community }}">
+	<meta property="og:description" content="View on Libreddit, an alternative private front-end to Reddit.">
+	<meta property="og:image" content="{{ post.thumbnail.url }}">
+	<meta property="twitter:card" content="summary_large_image">
+	<meta property="twitter:url" content="{{ post.permalink }}">
+	<meta property="twitter:title" content="{{ post.title }} - r/{{ post.community }}">
+	<meta property="twitter:description" content="View on Libreddit, an alternative private front-end to Reddit.">
+	<meta property="twitter:image" content="{{ post.thumbnail.url }}">
 {% endblock %}

 {% block subscriptions %}
 	{% call utils::sub_list(post.community.as_str()) %}
 {% endblock %}

-<!-- OPEN COMMENT MACRO -->
-{% macro comment(item) -%}
-<div id="{{ item.id }}" class="comment">
-	<div class="comment_left">
-		<p class="comment_score">{{ item.score }}</p>
-		<div class="line"></div>
-	</div>
-	<details class="comment_right" open>
-		<summary class="comment_data">
-			<a class="comment_author {{ item.author.distinguished }} {% if item.author.name == post.author.name %}op{% endif %}" href="/u/{{ item.author.name }}">u/{{ item.author.name }}</a>
-			{% if item.author.flair.flair_parts.len() > 0 %}
-				<small class="author_flair">{% call utils::render_flair(item.author.flair.flair_parts) %}</small>
-			{% endif %}
-			<span class="created" title="{{ post.created }}">{{ item.rel_time }}</span>
-		</summary>
-		<div class="comment_body">{{ item.body }}</div>
-{%- endmacro %}
-
-<!-- CLOSE COMMENT MACRO -->
-{% macro close() %}
-</details></div>
-{% endmacro %}
-
 {% block content %}
 	<div id="column_one">

@ -58,26 +47,42 @@
 			<p class="post_title">
 				<a href="{{ post.permalink }}">{{ post.title }}</a>
 				{% if post.flair.flair_parts.len() > 0 %}
-					<small class="post_flair" style="color:{{ post.flair.foreground_color }}; background:{{ post.flair.background_color }};">{% call utils::render_flair(post.flair.flair_parts) %}</small>
+					<a href="/r/{{ post.community }}/search/?q=flair_name%3A%22{{ post.flair.text }}%22&restrict_sr=on"
+						class="post_flair"
+						style="color:{{ post.flair.foreground_color }}; background:{{ post.flair.background_color }};">{% call utils::render_flair(post.flair.flair_parts) %}</a>
 				{% endif %}
 				{% if post.flags.nsfw %} <small class="nsfw">NSFW</small>{% endif %}
 			</p>

 			<!-- POST MEDIA -->
 			{% if post.post_type == "image" %}
-			<a href="{{ post.media.url }}" style="display:contents" >
-				<svg class="post_media" 
+			<a href="{{ post.media.url }}" class="post_media_image" >
+				<svg
 					width="{{ post.media.width }}px" 
 					height="{{ post.media.height }}px" 
 					xmlns="http://www.w3.org/2000/svg">
 						<image width="100%" height="100%" href="{{ post.media.url }}"/>
 						<desc>
 							<img alt="Post image" src="{{ post.media.url }}"/>
-						</dev>
+						</desc>
 				</svg>
 			</a>
 			{% else if post.post_type == "video" || post.post_type == "gif" %}
-			<video class="post_media" src="{{ post.media.url }}" controls autoplay loop></video>
+			<video class="post_media_video" src="{{ post.media.url }}" controls autoplay loop><a href={{ post.media.url }}>Video</a></video>
+			{% else if post.post_type == "gallery" %}
+			<div class="gallery">
+			{% for image in post.gallery -%}
+				<figure>
+					<a href="{{ image.url }}" ><img alt="Gallery image" src="{{ image.url }}"/></a>
+					<figcaption>
+						<p>{{ image.caption }}</p>
+						{% if image.outbound_url.len() > 0 %}
+						<p><a class="outbound_url" href="{{ image.outbound_url }}">{{ image.outbound_url }}</a>
+						{% endif %}
+					</figcaption>
+				</figure>
+			{%- endfor %}
+			</div>			
 			{% else if post.post_type == "link" %}
 			<a id="post_url" href="{{ post.media.url }}">{{ post.media.url }}</a>
 			{% endif %}
@ -110,25 +115,14 @@
 		<!-- COMMENTS -->
 		{% for c in comments -%}
 		<div class="thread">
-			<!-- EACH COMMENT -->
-			{% call comment(c) %}
-			<blockquote class="replies">{% for reply1 in c.replies %}{% call comment(reply1) %}
-				<!-- FIRST-LEVEL REPLIES -->
-				<blockquote class="replies">{% for reply2 in reply1.replies %}{% call comment(reply2) %}
-					<!-- SECOND-LEVEL REPLIES -->
-					<blockquote class="replies">{% for reply3 in reply2.replies %}{% call comment(reply3) %}
-						<!-- THIRD-LEVEL REPLIES -->
-						{% if reply3.replies.len() > 0 %}
-							<!-- LINK TO CONTINUE REPLIES -->
-							<a class="deeper_replies" href="{{ post.permalink }}{{ reply3.id }}">&rarr; More replies</a>
+			{% if single_thread %}
+			<p class="thread_nav"><a href="/{{ post.id }}">View all comments</a></p>
+			{% if c.parent_kind == "t1" %}
+			<p class="thread_nav"><a href="?context=9999">Show parent comments</a></p>
 			{% endif %}
-						{% call close() %}
-					{% endfor %}
-					</blockquote>{% call close() %}
-				{% endfor %}
-				</blockquote>{% call close() %}
-			{% endfor %}
-			</blockquote>{% call close() %}
+			{% endif %}
+			
+			{{ c.render().unwrap() }}
 		</div>
 		{%- endfor %}

--- a/templates/search.html
+++ b/templates/search.html
@ -48,54 +48,7 @@

 		{% if post.flags.nsfw && prefs.show_nsfw != "on" %}
 		{% else if post.title != "Comment" %}
-		<div class="post {% if post.flags.stickied %}stickied{% endif %}">	
-			<p class="post_header">
-				<a class="post_subreddit" href="/r/{{ post.community }}">r/{{ post.community }}</a>
-				<span class="dot">&bull;</span>
-				<a class="post_author" href="/u/{{ post.author.name }}">u/{{ post.author.name }}</a>
-				<span class="dot">&bull;</span>
-				<span class="created" title="{{ post.created }}">{{ post.rel_time }}</span>
-			</p>
-			<p class="post_title">
-				{% if post.flair.flair_parts.len() > 0 %}
-				<small class="post_flair" style="color:{{ post.flair.foreground_color }}; background:{{ post.flair.background_color }};">{% call utils::render_flair(post.flair.flair_parts) %}</small>
-				{% endif %}
-				<a href="{{ post.permalink }}">{{ post.title }}</a>{% if post.flags.nsfw %} <small class="nsfw">NSFW</small>{% endif %}
-			</p>
-			<!-- POST MEDIA/THUMBNAIL -->
-			{% if (prefs.layout.is_empty() || prefs.layout == "card") && post.post_type == "image" %}
-			<a href="{{ post.media.url }}" style="display:contents" >
-				<svg class="post_media {% if post.media.height /  post.media.width < 2 %}short{% endif %}" 
-					width="{{ post.media.width }}px" 
-					height="{{ post.media.height }}px" 
-					xmlns="http://www.w3.org/2000/svg">
-						<image width="100%" height="100%" href="{{ post.media.url }}"/>
-						<desc>
-							<img alt="Post image" src="{{ post.media.url }}"/>
-						</dev>
-				</svg>
-			</a>
-			{% else if post.post_type != "self" %}
-			<a class="post_thumbnail {% if post.thumbnail.url.is_empty() %}no_thumbnail{% endif %}" href="{% if post.post_type == "link" %}{{ post.media.url }}{% else %}{{ post.permalink }}{% endif %}">
-				{% if post.thumbnail.url.is_empty() %}
-				<svg viewBox="0 0 100 106" width="140" height="53" xmlns="http://www.w3.org/2000/svg">
-					<title>Thumbnail</title>
-					<path d="M35,15h-15a10,10 0,0,0 0,20h25a10,10 0,0,0 10,-10m-12.5,0a10, 10 0,0,1 10, -10h25a10,10 0,0,1 0,20h-15" fill="none" stroke-width="5" stroke-linecap="round"/>
-				</svg>
-				{% else %}
-				<svg width="{{ post.thumbnail.width }}px" height="{{ post.thumbnail.height }}px" xmlns="http://www.w3.org/2000/svg">
-					<image  alt="Thumbnail" width="100%" height="100%" href="{{ post.thumbnail.url }}"/>
-				</svg>
-				{% endif %}
-				<span>{% if post.post_type == "link" %}{{ post.domain }}{% else %}{{ post.post_type }}{% endif %}</span>
-			</a>
-			{% endif %}
-
-			<div class="post_score">{{ post.score }}<span class="label"> Upvotes</span></div>
-			<div class="post_footer">
-				<a href="{{ post.permalink }}" class="post_comments">{{ post.comments }} comments</a>
-			</div>
-		</div>
+		{% call utils::post_in_list(post) %}
 		{% else %}
 			<div class="comment">
 				<div class="comment_left">
--- a/templates/settings.html
+++ b/templates/settings.html
@ -9,13 +9,13 @@

 {% block content %}
 	<div id="settings">
-	<form action="/settings" method="POST">
+	<form action="/settings/" method="POST">
 		<div class="prefs">
 			<p>Appearance</p>
 			<div id="theme">
 				<label for="theme">Theme:</label>
 				<select name="theme"> 
-					{% call utils::options(prefs.theme, ["system", "light", "dark"], "system") %}
+					{% call utils::options(prefs.theme, ["system", "light", "dark", "black"], "system") %}
 				</select>
 			</div>
 			<p>Interface</p>
@ -46,25 +46,27 @@
 				<label for="show_nsfw">Show NSFW posts:</label>
 				<input type="checkbox" name="show_nsfw" {% if prefs.show_nsfw == "on" %}checked{% endif %}>
 			</div>
-		</div>
-		<p id="settings_note"><b>Note:</b> settings are saved in browser cookies. Clearing your cookie data will reset them.</p>
 			<input id="save" type="submit" value="Save">
+		</div>
 	</form>
-	{% if prefs.subs.len() > 0 %}
-		<aside class="prefs">
+	{% if prefs.subscriptions.len() > 0 %}
+		<div class="prefs" id="settings_subs">
 			<p>Subscribed Subreddits</p>
-			<ul id="settings_subs">
-				{% for sub in prefs.subs %}
-					<li>
+			{% for sub in prefs.subscriptions %}
+			<div>
 				<span>{{ sub }}</span>
-						<form action="/r/{{ sub }}/unsubscribe/?redirect=/settings" method="POST">
+				<form action="/r/{{ sub }}/unsubscribe/?redirect=settings" method="POST">
 						<button class="unsubscribe">Unsubscribe</button>
 				</form>
-					</li>
+			</div>
 			{% endfor %}
-			</ul>
-		</aside>
+		</div>
 	{% endif %}
+	
+	<div id="settings_note">
+		<p><b>Note:</b> settings and subscriptions are saved in browser cookies. Clearing your cookies will reset them.</p><br>
+		<p>You can restore your current settings and subscriptions after clearing your cookies using <a href="/settings/restore/?theme={{ prefs.theme }}&front_page={{ prefs.front_page }}&layout={{ prefs.layout }}&wide={{ prefs.wide }}&comment_sort={{ prefs.comment_sort }}&show_nsfw={{ prefs.show_nsfw }}&subscriptions={{ prefs.subscriptions.join("%2B") }}">this link</a>.</p>
+	</div>
 </div>

 {% endblock %}
--- a/templates/subreddit.html
+++ b/templates/subreddit.html
@ -39,58 +39,17 @@
 				{% endif %}
 			</form>

+			{% if sub.name.contains("+") %}
+				<form action="/r/{{ sub.name }}/subscribe/" method="POST">
+					<button id="multisub" class="subscribe" title="Subscribe to each sub in this multireddit">Subscribe to Multireddit</button>
+				</form>
+			{% endif %}
+
 			<div id="posts">
 			{% for post in posts %}
 			{% if !(post.flags.nsfw && prefs.show_nsfw != "on") %}
 			<hr class="sep" />
-			<div class="post {% if post.flags.stickied %}stickied{% endif %}">	
-				<p class="post_header">
-					<a class="post_subreddit" href="/r/{{ post.community }}">r/{{ post.community }}</a>
-					<span class="dot">&bull;</span>
-					<a class="post_author" href="/u/{{ post.author.name }}">u/{{ post.author.name }}</a>
-					<span class="dot">&bull;</span>
-					<span class="created" title="{{ post.created }}">{{ post.rel_time }}</span>
-				</p>
-				<p class="post_title">
-					{% if post.flair.flair_parts.len() > 0 %}
-					<small class="post_flair" style="color:{{ post.flair.foreground_color }}; background:{{ post.flair.background_color }};">{% call utils::render_flair(post.flair.flair_parts) %}</small>
-					{% endif %}
-					<a href="{{ post.permalink }}">{{ post.title }}</a>{% if post.flags.nsfw %} <small class="nsfw">NSFW</small>{% endif %}
-				</p>
-				<!-- POST MEDIA/THUMBNAIL -->
-				{% if (prefs.layout.is_empty() || prefs.layout == "card") && post.post_type == "image" %}
-				<a href="{{ post.media.url }}" style="display:contents" >
-					<svg class="post_media {% if post.media.height /  post.media.width < 2 %}short{% endif %}" 
-						width="{{ post.media.width }}px" 
-						height="{{ post.media.height }}px" 
-						xmlns="http://www.w3.org/2000/svg">
-							<image width="100%" height="100%" href="{{ post.media.url }}"/>
-							<desc>
-								<img alt="Post image" src="{{ post.media.url }}"/>
-							</dev>
-					</svg>
-				</a>
-				{% else if post.post_type != "self" %}
-				<a class="post_thumbnail {% if post.thumbnail.url.is_empty() %}no_thumbnail{% endif %}" href="{% if post.post_type == "link" %}{{ post.media.url }}{% else %}{{ post.permalink }}{% endif %}">
-					{% if post.thumbnail.url.is_empty() %}
-					<svg viewBox="0 0 100 106" width="140" height="53" xmlns="http://www.w3.org/2000/svg">
-						<title>Thumbnail</title>
-						<path d="M35,15h-15a10,10 0,0,0 0,20h25a10,10 0,0,0 10,-10m-12.5,0a10, 10 0,0,1 10, -10h25a10,10 0,0,1 0,20h-15" fill="none" stroke-width="5" stroke-linecap="round"/>
-					</svg>
-					{% else %}
-					<svg width="{{ post.thumbnail.width }}px" height="{{ post.thumbnail.height }}px" xmlns="http://www.w3.org/2000/svg">
-						<image  alt="Thumbnail" width="100%" height="100%" href="{{ post.thumbnail.url }}"/>
-					</svg>
-					{% endif %}
-					<span>{% if post.post_type == "link" %}{{ post.domain }}{% else %}{{ post.post_type }}{% endif %}</span>
-				</a>
-				{% endif %}
-
-				<div class="post_score">{{ post.score }}<span class="label"> Upvotes</span></div>
-				<div class="post_footer">
-					<a href="{{ post.permalink }}" class="post_comments">{{ post.comments }} comments</a>
-				</div>
-			</div>
+			{% call utils::post_in_list(post) %}
 			{% endif %}
 			{% endfor %}
 			</div>
@ -126,12 +85,12 @@
 						<div>{{ sub.active }}</div>
 					</div>
 					<div id="sub_subscription">
-						{% if prefs.subs.contains(sub.name) %}
-							<form action="/r/{{ sub.name }}/unsubscribe" method="POST">
+						{% if prefs.subscriptions.contains(sub.name) %}
+							<form action="/r/{{ sub.name }}/unsubscribe/" method="POST">
 								<button class="unsubscribe">Unsubscribe</button>
 							</form>
 						{% else %}
-							<form action="/r/{{ sub.name }}/subscribe" method="POST">
+							<form action="/r/{{ sub.name }}/subscribe/" method="POST">
 								<button class="subscribe">Subscribe</button>
 							</form>
 						{% endif %}
--- a/templates/user.html
+++ b/templates/user.html
@ -33,54 +33,7 @@

 			{% if post.flags.nsfw && prefs.show_nsfw != "on" %}
 			{% else if post.title != "Comment" %}
-			<div class="post {% if post.flags.stickied %}stickied{% endif %}">	
-				<p class="post_header">
-					<a class="post_subreddit" href="/r/{{ post.community }}">r/{{ post.community }}</a>
-					<span class="dot">&bull;</span>
-					<a class="post_author" href="/u/{{ post.author.name }}">u/{{ post.author.name }}</a>
-					<span class="dot">&bull;</span>
-					<span class="created" title="{{ post.created }}">{{ post.rel_time }}</span>
-				</p>
-				<p class="post_title">
-					{% if post.flair.flair_parts.len() > 0 %}
-					<small class="post_flair" style="color:{{ post.flair.foreground_color }}; background:{{ post.flair.background_color }};">{% call utils::render_flair(post.flair.flair_parts) %}</small>
-					{% endif %}
-					<a href="{{ post.permalink }}">{{ post.title }}</a>{% if post.flags.nsfw %} <small class="nsfw">NSFW</small>{% endif %}
-				</p>
-				<!-- POST MEDIA/THUMBNAIL -->
-				{% if (prefs.layout.is_empty() || prefs.layout == "card") && post.post_type == "image" %}
-				<a href="{{ post.media.url }}" style="display:contents" >
-					<svg class="post_media {% if post.media.height /  post.media.width < 2 %}short{% endif %}" 
-						width="{{ post.media.width }}px" 
-						height="{{ post.media.height }}px" 
-						xmlns="http://www.w3.org/2000/svg">
-							<image width="100%" height="100%" href="{{ post.media.url }}"/>
-							<desc>
-								<img alt="Post image" src="{{ post.media.url }}"/>
-							</dev>
-					</svg>
-				</a>
-				{% else if post.post_type != "self" %}
-				<a class="post_thumbnail {% if post.thumbnail.url.is_empty() %}no_thumbnail{% endif %}" href="{% if post.post_type == "link" %}{{ post.media.url }}{% else %}{{ post.permalink }}{% endif %}">
-					{% if post.thumbnail.url.is_empty() %}
-					<svg viewBox="0 0 100 106" width="140" height="53" xmlns="http://www.w3.org/2000/svg">
-						<title>Thumbnail</title>
-						<path d="M35,15h-15a10,10 0,0,0 0,20h25a10,10 0,0,0 10,-10m-12.5,0a10, 10 0,0,1 10, -10h25a10,10 0,0,1 0,20h-15" fill="none" stroke-width="5" stroke-linecap="round"/>
-					</svg>
-					{% else %}
-					<svg width="{{ post.thumbnail.width }}px" height="{{ post.thumbnail.height }}px" xmlns="http://www.w3.org/2000/svg">
-						<image  alt="Thumbnail" width="100%" height="100%" href="{{ post.thumbnail.url }}"/>
-					</svg>
-					{% endif %}
-					<span>{% if post.post_type == "link" %}{{ post.domain }}{% else %}{{ post.post_type }}{% endif %}</span>
-				</a>
-				{% endif %}
-
-				<div class="post_score">{{ post.score }}<span class="label"> Upvotes</span></div>
-				<div class="post_footer">
-					<a href="{{ post.permalink }}" class="post_comments">{{ post.comments }} comments</a>
-				</div>
-			</div>
+			{% call utils::post_in_list(post) %}
 			{% else %}
 			<div class="comment">
 				<div class="comment_left">
@ -112,7 +65,7 @@
 		</div>
 		<aside>
 			<div class="panel" id="user">
-				<img id="user_icon" src="{{ user.icon }}">
+				<img id="user_icon" src="{{ user.icon }}" alt="User icon">
 				<p id="user_title">{{ user.title }}</p>
 				<p id="user_name">u/{{ user.name }}</p>
 				<div id="user_description">{{ user.description }}</div>
--- a/templates/utils.html
+++ b/templates/utils.html
@ -1,7 +1,7 @@
 {% macro options(current, values, default) -%}
 	{% for value in values %}
 		<option value="{{ value }}" {% if current == value || (current == "" && value == default) %}selected{% endif %}>
-			{{ format!("{}{}", value.get(0..1).unwrap().to_uppercase(), value.get(1..).unwrap()) }}
+			{{ format!("{}{}", value.get(0..1).unwrap_or_default().to_uppercase(), value.get(1..).unwrap_or_default()) }}
 		</option>
 	{% endfor %}
 {%- endmacro %}
@ -9,7 +9,7 @@
 {% macro sort(root, methods, selected) -%}
 	{% for method in methods %}
 		<a {% if method == selected %}class="selected"{% endif %} href="{{ root }}/{{ method }}">
-			{{ format!("{}{}", method.get(0..1).unwrap().to_uppercase(), method.get(1..).unwrap()) }}
+			{{ format!("{}{}", method.get(0..1).unwrap_or_default().to_uppercase(), method.get(1..).unwrap_or_default()) }}
 		</a>
 	{% endfor %}
 {%- endmacro %}
@ -20,7 +20,7 @@
 	{% if root != "/r/" && !root.is_empty() %}
 	<div id="inside">
 		<input type="checkbox" name="restrict_sr" id="restrict_sr">
-		<label for="restrict_sr" class="search_label">in {{ root }}</label>
+		<label for="restrict_sr" class="search_label" title="Restrict search to this subreddit">in {{ root }}</label>
 	</div>
 	{% endif %}
 	<button class="submit">
@ -33,22 +33,84 @@
 </form>
 {%- endmacro %}

-{% macro render_flair(flair) -%}
-{% for flair_part in flair %}
-	{% if flair_part.flair_part_type == "emoji" %}<span class="emoji" style="background-image:url('{{ flair_part.value }}');"></span>
-	{% else if flair_part.flair_part_type == "text" %}<span>{{ flair_part.value }}</span>{% endif %}
-{% endfor %}
+{% macro render_flair(flair_parts) -%}
+	{% for flair_part in flair_parts %}{% if flair_part.flair_part_type == "emoji" %}<span class="emoji" style="background-image:url('{{ flair_part.value }}');"></span>{% else if flair_part.flair_part_type == "text" && !flair_part.value.is_empty() %}<span>{{ flair_part.value }}</span>{% endif %}{% endfor %}
 {%- endmacro %}

 {% macro sub_list(current) -%}
-{% if prefs.subs.len() > 0 %}
-	<details id="subscriptions">
-		<summary>Subscriptions</summary>
-		<div id="sub_list">
-			{% for sub in prefs.subs %}
+{% if prefs.subscriptions.len() > 0 %}
+	<details id="feeds">
+		<summary>Feeds</summary>
+		<div id="feed_list">
+			<p>MAIN FEEDS</p>
+			<a href="/">Home</a>
+			<a href="/r/popular">Popular</a>
+			<a href="/r/all">All</a>
+			<p>REDDIT FEEDS</p>
+			{% for sub in prefs.subscriptions %}
 				<a href="/r/{{ sub }}" {% if sub == current %}class="selected"{% endif %}>{{ sub }}</a>
 			{% endfor %}
 		</div>
 	</details>
 {% endif %}
 {%- endmacro %}
+
+{% macro post_in_list(post) -%}
+<div class="post {% if post.flags.stickied %}stickied{% endif %}">	
+	<p class="post_header">
+		<a class="post_subreddit" href="/r/{{ post.community }}">r/{{ post.community }}</a>
+		<span class="dot">&bull;</span>
+		<a class="post_author" href="/u/{{ post.author.name }}">u/{{ post.author.name }}</a>
+		<span class="dot">&bull;</span>
+		<span class="created" title="{{ post.created }}">{{ post.rel_time }}</span>
+	</p>
+	<p class="post_title">
+		{% if post.flair.flair_parts.len() > 0 %}
+			<a href="/r/{{ post.community }}/search/?q=flair_name%3A%22{{ post.flair.text }}%22&restrict_sr=on"
+				class="post_flair"
+				style="color:{{ post.flair.foreground_color }}; background:{{ post.flair.background_color }};">{% call render_flair(post.flair.flair_parts) %}</a>
+		{% endif %}
+		<a href="{{ post.permalink }}">{{ post.title }}</a>{% if post.flags.nsfw %} <small class="nsfw">NSFW</small>{% endif %}
+	</p>
+	<!-- POST MEDIA/THUMBNAIL -->
+	{% if (prefs.layout.is_empty() || prefs.layout == "card") && post.post_type == "image" %}
+	<a href="{{ post.media.url }}" class="post_media_image {% if post.media.height /  post.media.width < 2 %}short{% endif %}" >
+		<svg
+			width="{{ post.media.width }}px" 
+			height="{{ post.media.height }}px" 
+			xmlns="http://www.w3.org/2000/svg">
+				<image width="100%" height="100%" href="{{ post.media.url }}"/>
+				<desc>
+					<img alt="Post image" src="{{ post.media.url }}"/>
+				</desc>
+		</svg>
+	</a>
+	{% else if (prefs.layout.is_empty() || prefs.layout == "card") && post.post_type == "gif" %}
+	<video class="post_media_video short" src="{{ post.media.url }}" width="{{ post.media.width }}" height="{{ post.media.height }}" controls loop autoplay><a href={{ post.media.url }}>Video</a></video>
+	{% else if (prefs.layout.is_empty() || prefs.layout == "card") && post.post_type == "video" %}
+	<video class="post_media_video short" src="{{ post.media.url }}" width="{{ post.media.width }}" height="{{ post.media.height }}" poster="{{ post.media.poster }}" preload="none" controls autoplay><a href={{ post.media.url }}>Video</a></video>
+	{% else if post.post_type != "self" %}
+	<a class="post_thumbnail {% if post.thumbnail.url.is_empty() %}no_thumbnail{% endif %}" href="{% if post.post_type == "link" %}{{ post.media.url }}{% else %}{{ post.permalink }}{% endif %}">
+		{% if post.thumbnail.url.is_empty() %}
+		<svg viewBox="0 0 100 106" width="140" height="53" xmlns="http://www.w3.org/2000/svg">
+			<title>Thumbnail</title>
+			<path d="M35,15h-15a10,10 0,0,0 0,20h25a10,10 0,0,0 10,-10m-12.5,0a10, 10 0,0,1 10, -10h25a10,10 0,0,1 0,20h-15" fill="none" stroke-width="5" stroke-linecap="round"/>
+		</svg>
+		{% else %}
+		<svg width="{{ post.thumbnail.width }}px" height="{{ post.thumbnail.height }}px" xmlns="http://www.w3.org/2000/svg">
+			<image  width="100%" height="100%" href="{{ post.thumbnail.url }}"/>
+			<desc>
+				<img alt="Thumbnail" src="{{ post.thumbnail.url }}"/>
+			</desc>
+		</svg>
+		{% endif %}
+		<span>{% if post.post_type == "link" %}{{ post.domain }}{% else %}{{ post.post_type }}{% endif %}</span>
+	</a>
+	{% endif %}
+
+	<div class="post_score">{{ post.score }}<span class="label"> Upvotes</span></div>
+	<div class="post_footer">
+		<a href="{{ post.permalink }}" class="post_comments">{{ post.comments }} comments</a>
+	</div>
+</div>
+{%- endmacro %}
Author	SHA1	Message	Date
spikecodes	4b1195f221	Update to v0.4.2	2021-03-12 13:48:43 -08:00
spikecodes	a472461ee8	Switch some links in Readme to spike.codes instance	2021-03-12 12:59:50 -08:00
spikecodes	baf5e3d7ee	Fix Replit links	2021-03-12 12:55:02 -08:00
spikecodes	f209757ed6	Handle proxy unwraps	2021-03-12 12:21:02 -08:00
spikecodes	4173362ce1	Fix #148	2021-03-11 20:15:26 -08:00
spikecodes	b2ae5e486f	Rename subreddit::page to subreddit::community	2021-03-10 21:43:06 -08:00
spikecodes	cda19a1912	Remove duplicate "description" meta tag for posts	2021-03-10 21:41:39 -08:00
spikecodes	f0b69f8a4a	Update to v0.4	2021-03-10 20:51:08 -08:00
spikecodes	118ff9485c	Document proxy.rs	2021-03-10 19:02:03 -08:00
spikecodes	4a51b7cfb0	Horizontally squish comments	2021-03-10 15:10:59 -08:00
Spike	f877face80	Update README.md	2021-03-10 20:56:33 +00:00
spikecodes	f0e8deb000	Add alt attribute to user icon	2021-03-10 11:29:36 -08:00
spikecodes	e70dfe2c0b	Fix <video> size attributes	2021-03-10 10:49:18 -08:00
spikecodes	2e89a85858	Handle alternative status codes	2021-03-09 22:23:26 -08:00
spikecodes	e59b2b1346	Custom HTTP client with Rustls	2021-03-09 22:13:46 -08:00
spikecodes	1c36549134	Fix #146	2021-03-09 07:22:17 -08:00
spikecodes	5fb88d4744	Allow certain clippy lints	2021-03-08 19:22:10 -08:00
spikecodes	6c7188a1b9	Prevent pushing of Cargo.lock	2021-03-08 18:50:03 -08:00
spikecodes	84009fbb8e	Remove Cargo.lock	2021-03-08 18:49:35 -08:00
spikecodes	bf783c2f3a	Optimize type casting	2021-03-08 18:49:06 -08:00
spikecodes	213babb057	Update dependencies	2021-03-08 16:30:34 -08:00
Spike	7dbc02d930	Update himiko instances' location	2021-03-05 18:39:31 +00:00
spikecodes	10873dd0c6	Fix #144	2021-03-05 06:24:40 -08:00
Mennaruuk	c0d1519341	Update screenshot in README.md (#143 ) * Update screenshot in README.md New screenshot for v0.3.1. Also 35% lighter! * Update screenshot Co-authored-by: Spike <19519553+spikecodes@users.noreply.github.com>	2021-03-05 04:30:32 +00:00
Spike	8709c49f39	NGINX reverse proxy notice	2021-03-04 03:53:49 +00:00
spikecodes	56cfeba9e5	Update to v0.3.1	2021-03-03 09:35:40 -08:00
spikecodes	890d5ae625	Revert to curl-client	2021-03-03 09:24:31 -08:00
spikecodes	caa8f1d49e	Test h1-client	2021-03-03 09:15:19 -08:00
spikecodes	dd51b23dc4	Switch Surf backend to h1-client-rustls	2021-03-02 19:44:51 -08:00
Spike	52d9698879	Add british cow instances. Closes #141	2021-03-02 08:56:01 -08:00
spikecodes	20f6945160	Fix #140	2021-02-27 13:34:02 -08:00
spikecodes	10c73fad7f	Switch favicon to ico	2021-02-26 12:04:11 -08:00
spikecodes	2bddc952cb	Link comment timestamps. Closes #137	2021-02-25 21:53:27 -08:00
spikecodes	1de01d7283	Log errors to io::stderr	2021-02-25 16:21:56 -08:00
spikecodes	9183ce1921	Handle links in Media::parse	2021-02-25 11:43:58 -08:00
spikecodes	a197df89ff	Turn off media logging	2021-02-25 11:30:15 -08:00
spikecodes	be2a1d876b	Fix url rewrites	2021-02-25 11:01:25 -08:00
spikecodes	686d61801f	Fix #110	2021-02-25 10:24:37 -08:00
spikecodes	5d643277bc	Geometric logo	2021-02-25 09:07:45 -08:00
spikecodes	a3ec44149c	Categorize utilities	2021-02-24 21:29:23 -08:00
spikecodes	83ba0fb913	Reduce dependencies	2021-02-24 20:26:12 -08:00
spikecodes	55e9915bb0	Refactor post_body width	2021-02-24 11:28:26 -08:00
spikecodes	5cd5b553b0	Handle suspended users	2021-02-24 11:26:23 -08:00
Basti	2b2bd8421b	Added multi-staged container build and a user (#134 ) * Added multi-staged container build and a user This reduces the image size from 2Gb to 92Mb by only put the necessary files into the container. Container now runs without root priviliges. * Add EXPOSE to Dockerfile	2021-02-24 19:17:36 +00:00
spikecodes	47d01a0dca	Fix logging	2021-02-24 11:00:04 -08:00
Spike	0a69937238	Specify Ubuntu version of workflow	2021-02-24 18:44:50 +00:00
spikecodes	6d08f2dd24	Fix post body overflow on mobile	2021-02-24 09:31:58 -08:00
spikecodes	4a06882dc8	Simplify routes in main.rs	2021-02-24 09:26:01 -08:00
Spike	3e567d9acf	Add new instance	2021-02-23 12:54:39 -08:00
spikecodes	8034594006	Better subreddit error messages. Closes #131	2021-02-22 16:43:32 -08:00
spikecodes	2f3315dcfc	Fixes #130	2021-02-22 12:56:23 -08:00
Spike	df118764df	Update README.md	2021-02-22 05:45:56 +00:00
spikecodes	d78f82649e	List other images in manifest	2021-02-21 20:37:53 -08:00
spikecodes	80fb3a5c18	Fix #110	2021-02-21 20:28:04 -08:00
spikecodes	518d5753a7	Handle about pages	2021-02-21 10:13:20 -08:00
spikecodes	de38f7ef18	Fix post flairs	2021-02-21 10:11:17 -08:00
spikecodes	dd67b52199	Fix #126	2021-02-20 18:36:30 -08:00
spikecodes	9cfab348eb	Filter by flair. Closes #124	2021-02-20 13:59:16 -08:00
Spike	e1f7b6d0c0	Remove defunct Libreddit instance	2021-02-20 20:19:56 +00:00
spikecodes	a606e48435	Handle 4 more unwraps	2021-02-20 12:14:32 -08:00
spikecodes	2091f26bda	Fix media previews	2021-02-19 21:49:02 -08:00
spikecodes	b3341b49c0	Individually proxy subreddit and user icons	2021-02-19 21:46:44 -08:00
spikecodes	65e4ceff7b	Individually proxy previews	2021-02-19 20:50:55 -08:00
spikecodes	bacb22f7f9	Fix post url indentation	2021-02-19 18:19:04 -08:00
spikecodes	902c9a6e42	Individually proxy custom emojis	2021-02-19 18:18:09 -08:00
spikecodes	c586de66ba	Individually proxy images and thumbnails	2021-02-19 12:55:07 -08:00
spikecodes	e466be8946	Fix manifest and update dependencies	2021-02-19 11:10:48 -08:00
Spike	bed3465475	Remove "Options" and fix "Built With"	2021-02-19 09:20:09 -08:00
spikecodes	8560e8a37a	Add "port" command line argument	2021-02-18 11:49:50 -08:00
spikecodes	3652342f46	Use clap for arg parsing	2021-02-18 11:40:10 -08:00
spikecodes	58127b17d8	Individually proxy videos	2021-02-18 10:04:59 -08:00
spikecodes	2f4deb221a	Reduce dependencies	2021-02-16 11:39:56 -08:00
Kieran	38230ed473	Add more rich meta tags (#121 )	2021-02-16 19:16:32 +00:00
spikecodes	71501b064c	Update dependencies	2021-02-15 14:09:45 -08:00
spikecodes	47a58ea05c	Add CODEOWNERS file	2021-02-15 13:46:07 -08:00
spikecodes	14ecf3cf60	Edit indicator	2021-02-14 14:53:09 -08:00
spikecodes	aa7c8c85df	Templatize redirects	2021-02-13 15:02:38 -08:00
spikecodes	0cb7031c36	Fix focus outline	2021-02-13 13:38:12 -08:00
robrobinbin	93cfc713c6	Generate URL to restore settings, including subscriptions. Closes #89 (#116 ) * Start recursive comments * Update comment.html * Fix move error * Comment improvements * Fix merge * Remove extra endif from post.html * Fix post.html * Restore setting from link * Tweak settings page Co-authored-by: spikecodes <19519553+spikecodes@users.noreply.github.com>	2021-02-13 20:55:23 +00:00
spikecodes	ff8685ae4c	Add tooltips for accessibility	2021-02-12 20:53:33 -08:00
spikecodes	f06320a4ae	Subscribe to multireddit button. Closes #104	2021-02-12 20:47:54 -08:00
robrobinbin	809be42e01	Add "View all comments" and "Show parent comments" buttons when viewing a single thread. Closes #65 (#115 ) * Start recursive comments * Update comment.html * Fix move error * Comment improvements * Fix merge * Remove extra endif from post.html * Fix post.html Co-authored-by: spikecodes <19519553+spikecodes@users.noreply.github.com>	2021-02-12 09:16:59 -08:00
spikecodes	58ca085521	Fix subscription list overflow	2021-02-11 09:18:32 -08:00
robrobinbin	4a40e16277	Fix comment structuring (#113 ) * Start recursive comments * Update comment.html * Fix move error Co-authored-by: spikecodes <19519553+spikecodes@users.noreply.github.com>	2021-02-10 10:48:51 -08:00
spikecodes	fee2cb1b56	Split subscription names by +	2021-02-09 21:56:38 -08:00
spikecodes	8785bc95f5	Fix extra slashes in post bodies	2021-02-09 21:54:55 -08:00
Spike	16454213cf	Fix Dockerfile	2021-02-10 01:31:28 +00:00
spikecodes	6feb347c27	Fix post ID parsing	2021-02-09 12:08:38 -08:00
spikecodes	e731cfbac4	Support post links without titles	2021-02-09 10:11:39 -08:00
spikecodes	008924fff8	Fix listen address	2021-02-09 09:54:13 -08:00
Spike	ebbdd7185f	Move from Actix Web to Tide (#99 ) * Initial commit * Port posts * Pinpoint Tide Bug * Revert testing * Add basic sub support * Unwrap nested routes * Front page & sync templates * Port remaining functions * Log request errors * Clean main and settings * Handle /w/ requests * Create template() util * Reduce caching time to 30s * Fix subscription redirects * Handle frontpage sorting	2021-02-09 17:38:52 +00:00
spikecodes	402b3149e1	Fix 'no entry found for key' error	2021-02-07 17:56:06 -08:00
spikecodes	ac5ef89dff	Fix gallery unwrapping	2021-02-07 17:33:54 -08:00
robrobinbin	7edca18f8d	Inline videos/gifs for card view (#107 ) * Basic gallery support * Inline videos for card view	2021-02-08 00:22:14 +00:00
robrobinbin	cf45d53fdd	Basic gallery support (#103 )	2021-02-06 20:05:11 +00:00
curlpipe	2a475d127a	Added black theme (#101 )	2021-02-06 20:04:29 +00:00
FireMasterK	3fa523e67b	Add a multi-architecture docker build. (#98 ) * Add a multi-arch docker build. * Remove caching	2021-02-04 22:17:04 +00:00
spikecodes	3fbb433e37	Update dependencies	2021-02-03 21:48:56 -08:00
Spike	5fbcfd850f	Merge pull request #97 from Mennaruuk/master Fix installation method links	2021-02-03 21:46:28 -08:00
Spike	c758db84ec	Merge pull request #95 from robrobinbin/patch-5 Remove tiny "padding" below inline images	2021-02-03 21:45:11 -08:00
spikecodes	90d3063f93	Fix #96	2021-02-03 21:42:43 -08:00
Mennaruuk	82a601d534	Minor update to README.md	2021-02-04 00:39:46 -05:00
robrobinbin	12a1b3f459	Update style.css	2021-02-03 22:01:46 +01:00
Spike	e23eaf0be0	Merge pull request #92 from robrobinbin/master Fix layout on browsers with faulty "display: contents" support (Safari)	2021-02-03 11:55:04 -08:00
robin	821709c8d2	Resolve merge conflict	2021-02-03 20:14:37 +01:00
robin	653b0e7024	Don't use display contents and remove duplication	2021-02-03 20:11:04 +01:00
Spike	c7a2c43287	Merge pull request #93 from mcrossman/master Make feed sorting case-insensitive	2021-02-02 19:13:35 -08:00
Matthew Crossman	9824370771	Fix feed sorting to be case-insensitive.	2021-02-03 10:53:09 +11:00
robrobinbin	d87b96d0ea	Update style.css	2021-02-02 21:33:23 +01:00
robrobinbin	6eae4bc47a	Update style.css	2021-02-02 21:23:51 +01:00
robrobinbin	1bcb070fbb	Update user.html	2021-02-02 21:21:29 +01:00
robrobinbin	24bc758090	Update subreddit.html	2021-02-02 21:21:11 +01:00
robrobinbin	ffbb1cf7cd	Update search.html	2021-02-02 21:20:38 +01:00
robrobinbin	cbf1f540d6	Update post.html	2021-02-02 21:20:03 +01:00
robrobinbin	f8e0d2d4b9	Merge pull request #7 from spikecodes/master Merge upstream	2021-02-02 21:18:21 +01:00
Spike	8a27b2bac8	Support /w/ for Wikis	2021-02-02 08:59:50 -08:00
spikecodes	69941d9efd	Implement #88	2021-02-01 17:50:00 -08:00
spikecodes	956de50419	Change Libreddit PWA Theme Color	2021-02-01 16:26:35 -08:00
Spike	d790264a62	Merge pull request #87 from robrobinbin/master Add fallback to thumbnails when SVG is not supported	2021-02-01 12:53:03 -08:00
robrobinbin	f4f2d8a377	Update style.css	2021-02-01 21:02:38 +01:00
robrobinbin	dd908c9f68	Update user.html	2021-02-01 21:00:03 +01:00
robrobinbin	9e1948733d	Update subreddit.html	2021-02-01 20:59:31 +01:00
robrobinbin	9df1dfae32	Update search.html	2021-02-01 20:58:59 +01:00
robrobinbin	cfbee1bb81	Merge pull request #6 from spikecodes/master Merge upstream	2021-02-01 20:57:06 +01:00
Spike	8430cbc6f3	Merge pull request #86 from robrobinbin/patch-4 Place noscript placeholder into grid	2021-02-01 11:45:34 -08:00
robrobinbin	a9dd2e6f2c	Place noscript placeholder into grid	2021-02-01 20:43:32 +01:00
Spike	36964982fb	Merge pull request #85 from robrobinbin/master Improve support for browsers without inline SVG support	2021-02-01 11:39:35 -08:00
robrobinbin	0742a33304	Update base.html	2021-02-01 20:32:57 +01:00
robrobinbin	7f320b3143	Update style.css	2021-02-01 20:27:56 +01:00
robrobinbin	58f4fc4e77	Update user.html	2021-02-01 20:27:08 +01:00
robrobinbin	7d8faefad0	Update search.html	2021-02-01 20:26:35 +01:00
robrobinbin	ba9b5afd4e	Update post.html	2021-02-01 20:25:57 +01:00
robrobinbin	ae09f77bf6	Update subreddit.html	2021-02-01 20:25:06 +01:00
robrobinbin	5030c418de	Merge pull request #5 from spikecodes/master Merge upstream	2021-02-01 20:23:35 +01:00
Spike	4ccd6b1751	Merge pull request #84 from JPyke3/tor-service Added new Tor Hidden Service	2021-02-01 10:25:52 -08:00
Spike	7d17aa0627	Merge pull request #83 from JPyke3/master iOS "Add to Homescreen" functionality	2021-02-01 10:25:28 -08:00
JPyke3	4b73e2d914	Added personal Hidden Service	2021-02-01 18:44:55 +01:00
JPyke3	0a140a6ffc	Merge branch 'master' of github.com:JPyke3/libreddit into master	2021-02-01 11:13:36 +01:00
JPyke3	e837d84105	Add Support for iOS "Add to Homescreen" * Adds basic Manifest.json * Adds Meta Tags for iOS * Adds Meta Tags for Android * Adds Logo for Manifest.json * Adds iOS Logo for homescreen	2021-02-01 11:10:53 +01:00
spikecodes	f6d791ccd9	Style focus outline	2021-01-31 20:56:13 -08:00
spikecodes	effaeb7508	Fix debug logging error	2021-01-31 19:08:50 -08:00
spikecodes	6257faf9dc	Update screenshot	2021-01-31 19:05:06 -08:00