AlfarelSandriano Subektiansyah

• oxyst+

  A terminal editor for Typst documents with a live preview that never blocks typing.

  Rust, Ratatui, Typst, Criterion

  Screenshot goes here

  Role

  Sole developer

  Built with

  Rust, Ratatui, Typst, Criterion

  Links

  GitHub

  Problem

  Writing Typst in the terminal meant switching to another window or a browser to see the result. Running the compiler on every change also made typing stutter.

  Solution

  I built an editor with the Typst compiler inside it. It compiles in the background and draws the rendered pages right in the terminal.

  Technical challenges

  • Recompiling on every edit without ever blocking input
  • Drawing rendered pages in terminals with different image support
  • Keeping the preview and the cursor position in sync

  Engineering decisions

  • Embed the Typst compiler instead of calling the typst executable
  • Split the code into crates for the document, compiler, renderer and interface
  • Cache rendered pages and only redraw the ones that changed
  • Benchmark every core operation with Criterion before tuning it

  What I learned

  That a benchmark suite changes how you work. Once I could see the render step was the slow part, one cache gave a bigger win than any other change.

  Read the case study

• kifu+

  Tracks riichi mahjong stats from Tenhou game logs, for single games and whole careers.

  Rust, Cloudflare Workers, Cloudflare D1, Svelte, TypeScript

  Screenshot goes here

  Role

  Sole developer

  Built with

  Rust, Cloudflare Workers, Cloudflare D1, Svelte, TypeScript

  Links

  GitHub Live demo

  Problem

  Tenhou shows little more than placements after a game. I wanted to see my win rate, deal-ins and hand values over many games.

  Solution

  I built a site that fetches Tenhou game logs, parses every hand, and stores the results. It shows stats for a single game and for a player's whole career.

  Technical challenges

  • Parsing Tenhou's game log format hand by hand
  • Fetching logs politely so Tenhou never gets bursts of requests
  • Turning raw hands into stats like deal-in rates and yaku counts

  Engineering decisions

  • Keep the parser and stats in a pure Rust crate, apart from the API
  • Run the API as a Rust Worker with D1 for storage
  • Queue log fetches in a Durable Object, at least one second apart
  • Generate the TypeScript API types from the Rust types

  What I learned

  How to split a project so the hard part, the log parser and stats, can be tested on its own without a server or database.

  Read the case study

• ffff+

  A tiny stack-based esoteric language in Rust, where every command is spelled with f, u and a.

  Rust

  Screenshot goes here

  Role

  Sole developer

  Built with

  Rust

  Links

  GitHub

  Problem

  I wanted to learn how interpreters work from the inside. A small, silly language was the easiest way to try it end to end.

  Solution

  I designed a stack language with thirteen commands, including loops and input, and wrote its interpreter in Rust. It runs as a command-line tool or as a library.

  Technical challenges

  • Matching loop starts and ends before the program runs
  • Reporting bad programs clearly instead of crashing

  Engineering decisions

  • Validate the program and precompute loop jumps at parse time
  • Read and write through standard I/O traits so callers can pass files or buffers

  What I learned

  That doing the work once at parse time, like finding loop jumps, keeps the interpreter loop short and simple.

  Read the case study

• Discord Smasaku+

  A Discord bot for a school server that helps new members introduce themselves and get class roles.

  Rust, Serenity, Discord API

  Screenshot goes here

  Role

  Sole developer

  Built with

  Rust, Serenity, Discord API

  Links

  GitHub

  Problem

  New members joined the school's Discord server without saying who they were. Moderators also had to change everyone's class role by hand each school year.

  Solution

  I rewrote the server's bot in Rust with slash commands. Members introduce themselves through a command or a form, and a class command updates roles.

  Technical challenges

  • Handling both slash commands and modal forms from the same bot
  • Formatting names in introductions consistently

  Engineering decisions

  • Rust with Serenity for a small, reliable bot
  • One module per command so new commands are easy to add

  What I learned

  How Discord's interactions work, and how to keep a bot simple enough that others can add commands.

• IF Knowledge Repository+

  A shared library where Informatics students upload, sort and read study notes and PDFs.

  Rust, Axum, PostgreSQL, Cloudflare R2, Next.js, TypeScript

  Screenshot goes here

  Role

  Sole developer

  Built with

  Rust, Axum, PostgreSQL, Cloudflare R2, Next.js, TypeScript

  Links

  GitHub Live demo

  Problem

  Study notes and past materials were spread across chats and personal drives. Students had no single place to find them by course or topic.

  Solution

  I built a site where signed-in students upload notes in Markdown or as PDFs, sorted into categories. Anyone signed in can filter, read and download them.

  Technical challenges

  • Uploading large PDFs without passing them through the API server
  • Supporting both email and Google sign-in
  • Paging and filtering resources by category

  Engineering decisions

  • Presigned URLs so the browser uploads PDFs straight to R2
  • A Rust Axum API with SQLx and PostgreSQL
  • Argon2 password hashes and JWT sessions

  What I learned

  How presigned uploads keep large files off the API server, and what that changes about validating them.

• Event Management System+

  An event ticketing API in Rust, built to practice Clean Architecture and domain-driven design.

  Rust, Rocket, PostgreSQL, SQLx, Docker, OpenAPI

  Screenshot goes here

  Role

  Developer in a team of two

  Built with

  Rust, Rocket, PostgreSQL, SQLx, Docker, OpenAPI

  Links

  GitHub

  Problem

  Our Software Construction course gave us a ticketing case study with 20 user stories. The point was to show Clean Architecture and domain-driven design, not just a working API.

  Solution

  We split the system into domain, application, infrastructure and API crates. Every user story became a command or query handler behind a REST endpoint.

  Technical challenges

  • Keeping business rules in the domain, free of database code
  • Updating several aggregates in one transaction
  • Modeling booking, payment, check-in and refund states without gaps

  Engineering decisions

  • One crate per layer, so dependencies can only point inward
  • Payment, refunds and notifications behind ports with simulated adapters
  • Domain events for every important change, such as BookingPaid

  What I learned

  That ports and adapters pay off quickly: we could test the payment and refund rules long before any real payment service existed.

  Read the case study

• Simple PBFT demo+

  A four-node demo of the PBFT consensus algorithm over QUIC, written to learn how it works.

  Rust, Tokio, QUIC, rustls

  Screenshot goes here

  Role

  Sole developer

  Built with

  Rust, Tokio, QUIC, rustls

  Links

  GitHub

  Problem

  I had read about Practical Byzantine Fault Tolerance, but the papers did not make it click. I wanted to see the message rounds happen between real processes.

  Solution

  I wrote a small PBFT network in Rust: four replica nodes and a client. The nodes talk over QUIC with TLS certificates and sign their messages.

  Technical challenges

  • Getting four nodes to connect to each other reliably at startup
  • Following the pre-prepare, prepare and commit rounds correctly
  • Generating keys and certificates for every node

  Engineering decisions

  • QUIC with quinn and rustls for encrypted links between nodes
  • Compact binary messages with postcard
  • A separate client binary that sends requests to the replicas

  What I learned

  How quorums let a network agree even when one node lies, and how much of a consensus protocol is really just bookkeeping.

  Read the case study

Show all projects