diff --git a/230101/project.toml b/230101/project.toml
index 814e1c2..d90df0c 100644
--- a/230101/project.toml
+++ b/230101/project.toml
@@ -7,13 +7,9 @@ date = "230101"
 [source]
 files = ["C01.mp4", "C02.mp4", "C03.mp4"]
 stereo = false
-start = "1"
+start = "2"
 end = "12"
-fast = [["6", "8"], ["10", "11"]]
-questions = [
-	["1.5", "3", "Hallo liebes Publikum. Ich habe leider meine Frage vergessen. Bitte entschuldigt die Störung."],
-	["3.5", "5", "Ah jetzt weiß ich es wieder. Meine Frage war: Was war meine Frage?"]
-]
+fast = [["5", "7"], ["9", "11"]]
 
 [source.metadata]
 source_duration = "12.53000"
@@ -26,6 +22,5 @@ source_sample_rate = 48000
 preprocessed = false
 asked_start_end = true
 asked_fast = true
-asked_questions = true
 rendered = false
 transcoded = []
diff --git a/Cargo.toml b/Cargo.toml
index d73faad..bc0f991 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,10 +10,7 @@ license = "EPL-2.0"
 [dependencies]
 anyhow = "1.0"
 camino = "1.1"
-console = "0.15"
 clap = { version = "4.4", features = ["derive"] }
-fontconfig = "0.8"
-harfbuzz_rs = "2.0"
 indexmap = "2.2"
 rational = "1.5"
 serde = { version = "1.0.188", features = ["derive"] }
diff --git a/src/iotro.rs b/src/iotro.rs
index 98b5a50..94eca89 100644
--- a/src/iotro.rs
+++ b/src/iotro.rs
@@ -7,7 +7,7 @@ use std::{
 	str::FromStr
 };
 use svgwriter::{
-	tags::{Group, Rect, TagWithPresentationAttributes as _, Text},
+	tags::{Group, Rect, TagWithPresentationAttributes, Text},
 	Graphic
 };
 
@@ -134,14 +134,14 @@ impl Debug for Language<'_> {
 }
 
 #[repr(u16)]
-pub(crate) enum FontSize {
+enum FontSize {
 	Huge = 72,
 	Large = 56,
 	Big = 44
 }
 
 #[repr(u16)]
-pub(crate) enum FontWeight {
+enum FontWeight {
 	Normal = 400,
 	SemiBold = 500,
 	Bold = 700
diff --git a/src/main.rs b/src/main.rs
index 742ecd8..6c9a7ee 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,19 +3,16 @@
 #![forbid(elided_lifetimes_in_paths, unsafe_code)]
 
 mod iotro;
-mod question;
 mod render;
 mod time;
 
-use self::{
-	iotro::Language,
-	question::Question,
+use crate::{
 	render::{ffmpeg::FfmpegOutputFormat, Renderer},
 	time::{parse_date, parse_time, Date, Time}
 };
 use camino::Utf8PathBuf as PathBuf;
 use clap::Parser;
-use console::style;
+use iotro::Language;
 use rational::Rational;
 use serde::{Deserialize, Serialize};
 use serde_with::{serde_as, DisplayFromStr};
@@ -172,15 +169,9 @@ struct ProjectSource {
 	start: Option<Time>,
 	#[serde_as(as = "Option<DisplayFromStr>")]
 	end: Option<Time>,
-
-	#[serde(default)]
 	#[serde_as(as = "Vec<(DisplayFromStr, DisplayFromStr)>")]
 	fast: Vec<(Time, Time)>,
 
-	#[serde(default)]
-	#[serde_as(as = "Vec<(DisplayFromStr, DisplayFromStr, _)>")]
-	questions: Vec<(Time, Time, String)>,
-
 	metadata: Option<ProjectSourceMetadata>
 }
 
@@ -204,25 +195,10 @@ struct ProjectSourceMetadata {
 
 #[derive(Default, Deserialize, Serialize)]
 struct ProjectProgress {
-	#[serde(default)]
 	preprocessed: bool,
-
-	#[serde(default)]
 	asked_start_end: bool,
-
-	#[serde(default)]
 	asked_fast: bool,
-
-	#[serde(default)]
-	asked_questions: bool,
-
-	#[serde(default)]
-	rendered_assets: bool,
-
-	#[serde(default)]
 	rendered: bool,
-
-	#[serde(default)]
 	transcoded: BTreeSet<Resolution>
 }
 
@@ -230,44 +206,29 @@ fn ask(question: impl Display) -> String {
 	let mut stdout = io::stdout().lock();
 	let mut stdin = io::stdin().lock();
 
-	write!(
-		stdout,
-		"{} {} ",
-		style(question).bold().magenta(),
-		style(">").cyan()
-	)
-	.unwrap();
-	stdout.flush().unwrap();
+	writeln!(stdout, "{question}").unwrap();
 	let mut line = String::new();
+	write!(stdout, "> ").unwrap();
+	stdout.flush().unwrap();
 	stdin.read_line(&mut line).unwrap();
 	line.trim().to_owned()
 }
 
-fn ask_time(question: impl Display + Copy) -> Time {
+fn ask_time(question: impl Display) -> Time {
 	let mut stdout = io::stdout().lock();
 	let mut stdin = io::stdin().lock();
 
+	writeln!(stdout, "{question}").unwrap();
 	let mut line = String::new();
 	loop {
 		line.clear();
-		write!(
-			stdout,
-			"{} {} ",
-			style(question).bold().magenta(),
-			style(">").cyan()
-		)
-		.unwrap();
+		write!(stdout, "> ").unwrap();
 		stdout.flush().unwrap();
 		stdin.read_line(&mut line).unwrap();
 		let line = line.trim();
 		match parse_time(line) {
 			Ok(time) => return time,
-			Err(err) => writeln!(
-				stdout,
-				"{} {line:?}: {err}",
-				style("Invalid Input").bold().red()
-			)
-			.unwrap()
+			Err(err) => writeln!(stdout, "Invalid Input {line:?}: {err}").unwrap()
 		}
 	}
 }
@@ -311,14 +272,10 @@ fn main() {
 
 		print!("I found the following source files:");
 		for f in &files {
-			print!(" {}", style(f).bold().yellow());
+			print!(" {f}");
 		}
 		println!();
-		println!(
-			"{} Which source files would you like to use? (specify multiple files separated by whitespace)",
-			style("?").bold().yellow()
-		);
-		files = ask("files")
+		files = ask("Which source files would you like to use? (specify multiple files separated by whitespace)")
 			.split_ascii_whitespace()
 			.map(String::from)
 			.collect();
@@ -338,7 +295,6 @@ fn main() {
 				start: None,
 				end: None,
 				fast: Vec::new(),
-				questions: Vec::new(),
 				metadata: None
 			},
 			progress: Default::default()
@@ -358,21 +314,14 @@ fn main() {
 		fs::write(&project_path, toml::to_string(&project).unwrap().as_bytes()).unwrap();
 	}
 
-	println!();
-	println!(
-		" {} Preprocessed video: {}",
-		style("==>").bold().cyan(),
-		style(recording).bold().yellow()
-	);
-
 	// ask the user about start and end times
 	if !project.progress.asked_start_end {
-		println!(
-			"{} What is the first/last second you want included?",
-			style("?").bold().yellow()
-		);
-		project.source.start = Some(ask_time("first"));
-		project.source.end = Some(ask_time("last "));
+		project.source.start = Some(ask_time(format_args!(
+			"Please take a look at the file {recording} and tell me the first second you want included"
+		)));
+		project.source.end = Some(ask_time(format_args!(
+			"Please take a look at the file {recording} and tell me the last second you want included"
+		)));
 		project.progress.asked_start_end = true;
 
 		fs::write(&project_path, toml::to_string(&project).unwrap().as_bytes()).unwrap();
@@ -380,16 +329,16 @@ fn main() {
 
 	// ask the user about fast forward times
 	if !project.progress.asked_fast {
-		println!(
-			"{} Which sections of the video do you want fast-forwarded? (0 to finish)",
-			style("?").bold().yellow()
-		);
 		loop {
-			let start = ask_time("from");
+			let start = ask_time(format_args!(
+				"Please take a look at the file {recording} and tell me the first second you want fast-forwarded. You may reply with `0` if there are no more fast-forward sections"
+			));
 			if start.seconds == 0 && start.micros == 0 {
 				break;
 			}
-			let end = ask_time("to  ");
+			let end = ask_time(format_args!(
+				"Please tell me the last second you want fast-forwarded"
+			));
 			project.source.fast.push((start, end));
 		}
 		project.progress.asked_fast = true;
@@ -397,34 +346,6 @@ fn main() {
 		fs::write(&project_path, toml::to_string(&project).unwrap().as_bytes()).unwrap();
 	}
 
-	// ask the user about questions from the audience that should be subtitled
-	if !project.progress.asked_questions {
-		println!(
-			"{} In which sections of the video were questions asked you want subtitles for? (0 to finish)",
-			style("?").bold().yellow()
-		);
-		loop {
-			let start = ask_time("from");
-			if start.seconds == 0 && start.micros == 0 {
-				break;
-			}
-			let end = ask_time("to  ");
-			let text = ask("text");
-			project.source.questions.push((start, end, text));
-		}
-		project.progress.asked_questions = true;
-
-		fs::write(&project_path, toml::to_string(&project).unwrap().as_bytes()).unwrap();
-	}
-
-	// render the assets
-	if !project.progress.rendered_assets {
-		renderer.render_assets(&project).unwrap();
-		project.progress.rendered_assets = true;
-
-		fs::write(&project_path, toml::to_string(&project).unwrap().as_bytes()).unwrap();
-	}
-
 	// render the video
 	let mut videos = Vec::new();
 	videos.push(if project.progress.rendered {
@@ -457,18 +378,9 @@ fn main() {
 		}
 	}
 
-	println!();
-	println!(
-		" {} {}",
-		style("==>").bold().cyan(),
-		style("DONE :)").bold()
-	);
+	println!("\x1B[1m ==> DONE :)\x1B[0m");
 	println!("     Videos:");
 	for v in &videos {
-		println!(
-			"     {} {}",
-			style("->").bold().cyan(),
-			style(v).bold().yellow()
-		);
+		println!("     -> {v}");
 	}
 }
diff --git a/src/question.rs b/src/question.rs
deleted file mode 100644
index 0d7e3fc..0000000
--- a/src/question.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use crate::{iotro::Language, Resolution};
-use fontconfig::Fontconfig;
-use harfbuzz_rs::{Face, Font, Owned, UnicodeBuffer};
-use std::sync::OnceLock;
-use svgwriter::{
-	tags::{Group, Path, Rect, TSpan, TagWithPresentationAttributes as _, Text},
-	Data, Graphic, Transform
-};
-
-pub(crate) struct Question {
-	res: Resolution,
-	g: Group
-}
-
-impl Question {
-	pub(crate) fn new(res: Resolution, lang: &Language<'_>, str: &str) -> Self {
-		static FONT: OnceLock<Owned<Font<'static>>> = OnceLock::new();
-		let font = FONT.get_or_init(|| {
-			let fc = Fontconfig::new().unwrap();
-			let font_path = fc.find("Noto Sans", None).unwrap().path;
-			let face = Face::from_file(font_path, 0).unwrap();
-			Font::new(face)
-		});
-		let upem = font.face().upem();
-
-		// constants
-		let border_r = 12;
-		let font_size = 44;
-		let line_height = font_size * 6 / 5;
-		let padding = font_size / 2;
-		let margin_x = 240;
-		let margin_y = padding * 3 / 2;
-		let question_offset = 64;
-		let question_width = 240;
-
-		// calculated
-		let box_width = 1920 - 2 * margin_x;
-		let text_width = box_width - 2 * padding;
-
-		// calculates the width of the given string
-		let width_of = |s: &str| {
-			let width: i32 =
-				harfbuzz_rs::shape(font, UnicodeBuffer::new().add_str(s), &[])
-					.get_glyph_positions()
-					.iter()
-					.map(|glyph_pos| glyph_pos.x_advance)
-					.sum();
-			(width * font_size) / upem as i32
-		};
-		let space_width = width_of(" ");
-
-		// lay out the text
-		let mut text = Text::new()
-			.with_dominant_baseline("hanging")
-			.with_transform(
-				Transform::new().translate(padding, padding + font_size / 2 + border_r)
-			);
-		let words = str.split_whitespace();
-		let mut text_height = 0;
-		let mut text_x = 0;
-		for word in words {
-			let word_width = width_of(word);
-			if text_x + word_width > text_width {
-				text_x = 0;
-				text_height += line_height;
-			}
-			text.push(
-				TSpan::new()
-					.with_x(text_x)
-					.with_y(text_height)
-					.append(word.to_owned())
-			);
-			text_x += word_width + space_width;
-		}
-		text_height += font_size;
-
-		// calculated
-		let box_height = text_height + 2 * padding + font_size / 2 + border_r;
-
-		let mut g = Group::new()
-			.with_fill("white")
-			.with_font_family("Noto Sans")
-			.with_font_size(font_size)
-			.with_transform(
-				Transform::new().translate(margin_x, 1080 - margin_y - box_height)
-			);
-
-		let mut outline = Data::new();
-		outline.move_by(border_r, 0).horiz_line_to(question_offset);
-		outline
-			.vert_line_by(-font_size / 2)
-			.arc_by(border_r, border_r, 0, false, true, border_r, -border_r)
-			.horiz_line_by(question_width)
-			.arc_by(border_r, border_r, 0, false, true, border_r, border_r)
-			.vert_line_by(font_size)
-			.arc_by(border_r, border_r, 0, false, true, -border_r, border_r)
-			.horiz_line_by(-question_width)
-			.arc_by(border_r, border_r, 0, false, true, -border_r, -border_r)
-			.vert_line_by(-font_size / 2)
-			.move_by(question_width + 2 * border_r, 0);
-		outline
-			.horiz_line_to(box_width - border_r)
-			.arc_by(border_r, border_r, 0, false, true, border_r, border_r)
-			.vert_line_by(box_height - 2 * border_r)
-			.arc_by(border_r, border_r, 0, false, true, -border_r, border_r)
-			.horiz_line_to(border_r)
-			.arc_by(border_r, border_r, 0, false, true, -border_r, -border_r)
-			.vert_line_to(border_r)
-			.arc_by(border_r, border_r, 0, false, true, border_r, -border_r);
-		g.push(
-			Path::new()
-				.with_stroke("#fff")
-				.with_stroke_width(3)
-				.with_fill("#000")
-				.with_fill_opacity(".3")
-				.with_d(outline)
-		);
-		g.push(
-			Text::new()
-				.with_x(question_offset + question_width / 2 + border_r)
-				.with_y(0)
-				.with_dominant_baseline("middle")
-				.with_text_anchor("middle")
-				.with_font_weight(600)
-				.append("Question")
-		);
-		g.push(text);
-
-		Self { res, g }
-	}
-
-	pub(crate) fn finish(self) -> Graphic {
-		let mut svg = Graphic::new();
-		svg.set_width(self.res.width());
-		svg.set_height(self.res.height());
-		svg.set_view_box("0 0 1920 1080");
-		svg.push(self.g);
-		svg
-	}
-}
-
-#[cfg(test)]
-#[test]
-fn question() {
-	let svg = Question::new(
-		Resolution::FullHD,
-		&Language::default(),
-		"Hallo Welt! Dies ist eine sehr kluge Frage aus dem Publikum. Die Frage ist nämlich: Was ist eigentlich die Frage?".into()
-	)
-	.finish();
-	std::fs::write("question.svg", svg.to_string_pretty()).unwrap();
-}
diff --git a/src/render/filter.rs b/src/render/filter.rs
index 70832f4..dd82ecb 100644
--- a/src/render/filter.rs
+++ b/src/render/filter.rs
@@ -19,7 +19,6 @@ pub(crate) enum Filter {
 		overlay_input: Cow<'static, str>,
 		x: Cow<'static, str>,
 		y: Cow<'static, str>,
-		repeatlast: bool,
 		output: Cow<'static, str>
 	},
 
@@ -38,22 +37,6 @@ pub(crate) enum Filter {
 		output: Cow<'static, str>
 	},
 
-	/// Fade only video using the alpha channel.
-	FadeAlpha {
-		input: Cow<'static, str>,
-		direction: &'static str,
-		start: Time,
-		duration: Time,
-		output: Cow<'static, str>
-	},
-
-	/// Offset the PTS of the video by the amount of seconds.
-	VideoOffset {
-		input: Cow<'static, str>,
-		seconds: Time,
-		output: Cow<'static, str>
-	},
-
 	/// Generate silence. The video is copied.
 	GenerateSilence {
 		video: Cow<'static, str>,
@@ -94,13 +77,11 @@ impl Filter {
 				overlay_input,
 				x,
 				y,
-				repeatlast,
 				output
 			} => {
-				let repeatlast: u8 = (*repeatlast).into();
 				writeln!(
 					complex,
-					"{}{}overlay=x={x}:y={y}:repeatlast={repeatlast}:eval=init{};",
+					"{}{}overlay=x={x}:y={y}{};",
 					channel('v', video_input),
 					channel('v', overlay_input),
 					channel('v', output)
@@ -148,34 +129,6 @@ impl Filter {
 				)?;
 			},
 
-			Self::FadeAlpha {
-				input,
-				direction,
-				start,
-				duration,
-				output
-			} => {
-				writeln!(
-					complex,
-					"{}fade={direction}:st={start}:d={duration}:alpha=1{};",
-					channel('v', input),
-					channel('v', output)
-				)?;
-			},
-
-			Self::VideoOffset {
-				input,
-				seconds,
-				output
-			} => {
-				writeln!(
-					complex,
-					"{}setpts=PTS+{seconds}/TB{};",
-					channel('v', input),
-					channel('v', output)
-				)?;
-			},
-
 			Self::GenerateSilence { video, output } => {
 				writeln!(
 					complex,
diff --git a/src/render/mod.rs b/src/render/mod.rs
index 15fdf80..012ff2c 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -7,14 +7,12 @@ use self::{
 };
 use crate::{
 	iotro::{intro, outro},
-	question::Question,
 	render::ffmpeg::{Ffmpeg, FfmpegInput},
-	time::{format_date, format_time, Time},
+	time::{format_date, Time},
 	Project, ProjectLecture, ProjectSourceMetadata, Resolution
 };
 use anyhow::{bail, Context};
 use camino::{Utf8Path as Path, Utf8PathBuf as PathBuf};
-use console::style;
 use std::{
 	borrow::Cow,
 	collections::VecDeque,
@@ -35,10 +33,6 @@ const TRANSITION_LEN: Time = Time {
 	seconds: 0,
 	micros: 200_000
 };
-const QUESTION_FADE_LEN: Time = Time {
-	seconds: 0,
-	micros: 400_000
-};
 const FF_MULTIPLIER: usize = 8;
 // logo sizes at full hd, will be scaled to source resolution
 const FF_LOGO_SIZE: usize = 128;
@@ -157,13 +151,14 @@ fn svg2mkv(
 	ffmpeg.run()
 }
 
-fn svg2png(svg: &Path, png: &Path, width: usize, height: usize) -> anyhow::Result<()> {
+fn svg2png(svg: &Path, png: &Path, size: usize) -> anyhow::Result<()> {
 	let mut cmd = cmd();
+	let size = size.to_string();
 	cmd.arg("inkscape")
 		.arg("-w")
-		.arg(width.to_string())
+		.arg(&size)
 		.arg("-h")
-		.arg(height.to_string());
+		.arg(&size);
 	cmd.arg(svg).arg("-o").arg(png);
 
 	let status = cmd.status()?;
@@ -222,14 +217,6 @@ impl<'a> Renderer<'a> {
 		self.target.join("outro.mkv")
 	}
 
-	fn question_svg(&self, q_idx: usize) -> PathBuf {
-		self.target.join(format!("question{q_idx}.svg"))
-	}
-
-	fn question_png(&self, q_idx: usize) -> PathBuf {
-		self.target.join(format!("question{q_idx}.png"))
-	}
-
 	pub(crate) fn preprocess(&self, project: &mut Project) -> anyhow::Result<()> {
 		assert!(!project.progress.preprocessed);
 
@@ -240,13 +227,7 @@ impl<'a> Renderer<'a> {
 		}
 		drop(file);
 
-		println!();
-		println!(
-			" {} {}",
-			style("==>").bold().cyan(),
-			style("Concatenating Video and Normalising Audio ...").bold()
-		);
-
+		println!("\x1B[1m ==> Concatenating Video and Normalising Audio ...\x1B[0m");
 		let source_sample_rate =
 			ffprobe_audio("stream=sample_rate", &recording_txt)?.parse()?;
 		let recording_mkv = self.recording_mkv();
@@ -278,26 +259,15 @@ impl<'a> Renderer<'a> {
 			source_res,
 			source_sample_rate
 		});
-
-		Ok(())
-	}
-
-	/// Prepare assets like intro, outro and questions.
-	pub(crate) fn render_assets(&self, project: &Project) -> anyhow::Result<()> {
 		let metadata = project.source.metadata.as_ref().unwrap();
 
-		println!();
-		println!(
-			" {} {}",
-			style("==>").bold().cyan(),
-			style("Preparing assets ...").bold()
-		);
+		println!("\x1B[1m ==> Preparing assets ...\x1B[0m");
 
 		// render intro to svg then mp4
 		let intro_svg = self.target.join("intro.svg");
 		fs::write(
 			&intro_svg,
-			intro(metadata.source_res, &project.lecture)
+			intro(source_res, &project.lecture)
 				.to_string_pretty()
 				.into_bytes()
 		)?;
@@ -308,7 +278,7 @@ impl<'a> Renderer<'a> {
 		let outro_svg = self.target.join("outro.svg");
 		fs::write(
 			&outro_svg,
-			outro(&project.lecture.lang, metadata.source_res)
+			outro(&project.lecture.lang, source_res)
 				.to_string_pretty()
 				.into_bytes()
 		)?;
@@ -322,8 +292,7 @@ impl<'a> Renderer<'a> {
 			include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/assets/logo.svg"))
 		)?;
 		let logo_png = self.target.join("logo.png");
-		let logo_size = LOGO_SIZE * metadata.source_res.width() / 1920;
-		svg2png(&logo_svg, &logo_png, logo_size, logo_size)?;
+		svg2png(&logo_svg, &logo_png, LOGO_SIZE * source_res.width() / 1920)?;
 
 		// copy fastforward then render to png
 		let fastforward_svg = self.target.join("fastforward.svg");
@@ -335,31 +304,12 @@ impl<'a> Renderer<'a> {
 			))
 		)?;
 		let fastforward_png = self.target.join("fastforward.png");
-		let ff_logo_size = FF_LOGO_SIZE * metadata.source_res.width() / 1920;
 		svg2png(
 			&fastforward_svg,
 			&fastforward_png,
-			ff_logo_size,
-			ff_logo_size
+			FF_LOGO_SIZE * source_res.width() / 1920
 		)?;
 
-		// write questions then render to png
-		for (q_idx, (_, _, q_text)) in project.source.questions.iter().enumerate() {
-			let q = Question::new(metadata.source_res, &project.lecture.lang, q_text)
-				.finish()
-				.to_string_pretty()
-				.into_bytes();
-			let q_svg = self.question_svg(q_idx);
-			let q_png = self.question_png(q_idx);
-			fs::write(&q_svg, q)?;
-			svg2png(
-				&q_svg,
-				&q_png,
-				metadata.source_res.width(),
-				metadata.source_res.height()
-			)?;
-		}
-
 		Ok(())
 	}
 
@@ -399,24 +349,21 @@ impl<'a> Renderer<'a> {
 		let mut part3: Cow<'static, str> = outro.into();
 
 		// the recording is fun because of all the fast forwarding
-		let mut part2 = VecDeque::<Cow<'static, str>>::new();
-		let mut part2_ts = VecDeque::new();
+		let mut part2 = VecDeque::new();
 		let mut part2_start_of_the_end = None;
 		let mut part2_end_of_the_start = None;
 
 		// ok so ff is fun. we will add the ff'ed section as well as the part between
-		// the previous ff'ed section and our new section, unless we are the first.
+		// the previous ff'ed section and our new section, unless we are the first
 		project.source.fast.sort();
 		for (i, (ff_st, ff_end)) in project.source.fast.iter().rev().enumerate() {
 			if let Some(prev_end) = part2_end_of_the_start {
-				let duration = prev_end - *ff_end;
 				let recffbetween = ffmpeg.add_input(FfmpegInput {
 					start: Some(*ff_end),
-					duration: Some(duration),
+					duration: Some(prev_end - *ff_end),
 					..FfmpegInput::new(rec_file.clone())
 				});
 				part2.push_front(recffbetween.into());
-				part2_ts.push_front(Some((*ff_end, duration)));
 			} else {
 				part2_start_of_the_end = Some(*ff_end);
 			}
@@ -436,7 +383,6 @@ impl<'a> Renderer<'a> {
 				output: recff.clone().into()
 			});
 			part2.push_front(recff.into());
-			part2_ts.push_front(None);
 		}
 
 		// if the recording was not ff'ed, perform a normal trim
@@ -451,112 +397,23 @@ impl<'a> Renderer<'a> {
 				..FfmpegInput::new(rec_file.clone())
 			});
 			part2.push_back(rectrim.into());
-			part2_ts.push_back(Some((start, part2_last_part_duration)));
 		}
 		// otherwise add the first and last parts separately
 		else {
-			let duration = part2_end_of_the_start.unwrap() - start;
 			let rectrimst = ffmpeg.add_input(FfmpegInput {
 				start: Some(start),
-				duration: Some(duration),
+				duration: Some(part2_end_of_the_start.unwrap() - start),
 				..FfmpegInput::new(rec_file.clone())
 			});
 			part2.push_front(rectrimst.into());
-			part2_ts.push_front(Some((start, duration)));
 
-			let part2_start_of_the_end = part2_start_of_the_end.unwrap();
-			part2_last_part_duration = end - part2_start_of_the_end;
+			part2_last_part_duration = end - part2_start_of_the_end.unwrap();
 			let rectrimend = ffmpeg.add_input(FfmpegInput {
-				start: Some(part2_start_of_the_end),
+				start: Some(part2_start_of_the_end.unwrap()),
 				duration: Some(part2_last_part_duration),
 				..FfmpegInput::new(rec_file.clone())
 			});
 			part2.push_back(rectrimend.into());
-			part2_ts.push_back(Some((part2_start_of_the_end, part2_last_part_duration)));
-		}
-
-		// ok now we have a bunch of parts and a bunch of questions that want to get
-		// overlayed over those parts.
-		project.source.questions.sort();
-		let mut q_idx = 0;
-		for (i, ts) in part2_ts.iter().enumerate() {
-			let Some((start, duration)) = ts else {
-				continue;
-			};
-			loop {
-				if q_idx >= project.source.questions.len() {
-					break;
-				}
-				let (q_start, q_end, _) = &project.source.questions[q_idx];
-				if q_start < start {
-					bail!(
-						"Question starting at {} did not fit into the video",
-						format_time(*q_start)
-					);
-				}
-				if q_start >= start && *q_end <= *start + *duration {
-					// add the question as input to ffmpeg
-					let q_inp = ffmpeg.add_input(FfmpegInput {
-						loop_input: true,
-						fps: Some(project.source.metadata.as_ref().unwrap().source_fps),
-						duration: Some(*q_end - *q_start),
-						..FfmpegInput::new(self.question_png(q_idx))
-					});
-
-					// fade in the question
-					let q_fadein = format!("q{q_idx}fin");
-					ffmpeg.add_filter(Filter::FadeAlpha {
-						input: q_inp.into(),
-						direction: "in",
-						start: Time {
-							seconds: 0,
-							micros: 0
-						},
-						duration: QUESTION_FADE_LEN,
-						output: q_fadein.clone().into()
-					});
-
-					// fade out the question
-					let q_fadeout = format!("q{q_idx}fout");
-					ffmpeg.add_filter(Filter::FadeAlpha {
-						input: q_fadein.into(),
-						direction: "out",
-						start: *q_end - *q_start - QUESTION_FADE_LEN,
-						duration: QUESTION_FADE_LEN,
-						output: q_fadeout.clone().into()
-					});
-
-					// move the question to the correct timestamp
-					let q_pts = format!("q{q_idx}pts");
-					ffmpeg.add_filter(Filter::VideoOffset {
-						input: q_fadeout.into(),
-						seconds: *q_start - *start,
-						output: q_pts.clone().into()
-					});
-
-					// overlay the part in question
-					let q_overlay = format!("q{q_idx}o");
-					ffmpeg.add_filter(Filter::Overlay {
-						video_input: part2[i].clone(),
-						overlay_input: q_pts.into(),
-						x: "0".into(),
-						y: "0".into(),
-						repeatlast: false,
-						output: q_overlay.clone().into()
-					});
-					part2[i] = q_overlay.into();
-
-					q_idx += 1;
-					continue;
-				}
-				break;
-			}
-		}
-		if q_idx < project.source.questions.len() {
-			bail!(
-				"Question starting at {} did not fit into the video before it was over",
-				format_time(project.source.questions[q_idx].0)
-			);
 		}
 
 		// fade out the intro
@@ -634,7 +491,6 @@ impl<'a> Renderer<'a> {
 			overlay_input: logoalpha.into(),
 			x: format!("main_w-overlay_w-{overlay_off_x}").into(),
 			y: format!("main_h-overlay_h-{overlay_off_y}").into(),
-			repeatlast: true,
 			output: overlay.into()
 		});
 
@@ -652,13 +508,7 @@ impl<'a> Renderer<'a> {
 	) -> anyhow::Result<PathBuf> {
 		let input = self.video_file_output();
 		let output = self.video_file_res(res);
-
-		println!();
-		println!(
-			" {} {}",
-			style("==>").bold().cyan(),
-			style(format!("Rescaling to {}p", res.height())).bold()
-		);
+		println!("\x1B[1m ==> Rescaling to {}p\x1B[0m", res.height());
 
 		let mut ffmpeg = Ffmpeg::new(FfmpegOutput {
 			video_bitrate: Some(res.bitrate()),