Bassie's Bron des Codes

My personal monorepo for most of my hobby projects

Projects

Apps / Games

Some desktop apps and games written with the bwindow, bwebview, and bcanvas libraries.

2048	BassieLight	Binman	MacView	ManExplorer
Music Downloader	Navidrome	Pixel Font Editor	Reversi	Sequel Explorer

• 2048 An offline desktop 2048 game app
• BassieLight A simple lights controller with GUI
• Binman A safe and minimal Windows cleanup tool
• Empires An Age of Empires rendering demo and DRS archive viewer using SDL2
• MacView A macOS bitmap, QOI, SVG, and TinyVG image viewer with Quick Look preview and thumbnail
• ManExplorer A simple man page explorer tool
• Nintendo DS Ports DOOM, Duke Nukem 3D, Quake, Quake II, and Wolfenstein 3D ports
• Navidrome A music.bplaat.nl webview wrapper
• Music Downloader A tool that downloads complete albums with the correct metadata
• Pixel Font Editor An 8x8 pixel font editor
• PlaatCraft A Minecraft like voxel sandbox, also ported to the Wii
• Reversi A native canvas board game with a background AI
• Sequel Explorer A read-only SQLite and MySQL database GUI viewer

Tools / Websites

Various tools and websites. For the deployed sites, go to bron.bplaat.nl.

• baksteen A brick-laying robot simulator
• bob A simple build system for my projects, because I like the simplicity of Cargo
• ccontinue A transpiler that translates an OOP extension for the C programming language back to C
• cargo-bundle A simple Cargo plugin that builds macOS and iOS app bundles, Windows MSIX packages and Android APKs
• plaatnotes A self-hosted note-taking web app with rich Markdown support
• nds-toolchain An LLVM-based Nintendo DS toolchain with picolibc and a test ROM
• wii-toolchain An LLVM-based Wii toolchain with picolibc, libogc, the gxtexconv texture converter, and Dolphin emulator tests

Examples

• macOS Examples Mach-O assembly, Cocoa, Metal, OpenGL, and iOS examples
• Wii Examples Wii homebrew examples in C and Rust: triangles, a 2D canvas, and voxel blocks
• Windows Examples 32-bit and 64-bit Windows assembly examples using NASM

Libraries

Most of these libraries are intended primarily for personal use, but can still be useful. Many of them are minimal replacements for commonly used crates.

User Interfaces

• bwebview A cross-platform webview library for Rust with minimal dependencies
• bwindow Native windows and one typed main event loop
• plaatui A Preact web components ui library for my own services

Graphics

• bcanvas Native 2D canvas content, without a browser dependency
• image A minimal JPEG, PNG/APNG, GIF, BMP, and QOI image decoder crate
• vector SVG (subset) and TinyVG decoders with a backend-neutral display list
• bwebgpu A native GPU rendering library for bwindow
• bwebgpu-shader-build Build-time native WGSL compilation for bwebgpu

Apple

• block2 A minimal replacement for the block2 crate
• objc2 A minimal replacement for the objc2 crate
• objc2-proc-macros A minimal replacement for the objc2-proc-macros crate

Networking

• local-ip-address A minimal replacement for the local-ip-address crate
• maxminddb A minimal replacement for the maxminddb crate
• mime A minimal replacement for the mime crate
• mime_guess A minimal replacement for the mime_guess crate
• native-tls A minimal replacement for the native-tls crate
• simple-useragent A simple user agent parser library based on the uap-core regexes (crates.io)
• small-http A simple and small HTTP/1.1 server/client library
• small-router A simple and small router for the small-http library
• small-websocket A simple and small WebSocket library for the small-http library
• url A minimal replacement for the url crate

Data

• base64 A minimal replacement for the base64 crate
• bsql A simple and minimal Rust SQLite and MySQL library with an ergonomic API
• bsql_derive The derive macros for the bsql crate
• chrono A minimal replacement for the chrono crate
• crc A minimal replacement for the crc crate
• deflate A Deflate and zlib compression library with an optimal parsing mode
• from_derive A FromEnum and FromStruct derive macro library
• gzip A gzip library and command-line utility with a benchmark
• libsqlite3-sys A minimal replacement for the libsqlite3-sys crate
• plist A minimal replacement for the plist crate
• regex A minimal replacement for the regex crate
• serde_yaml A minimal replacement for the serde_yaml crate
• uuid A minimal replacement for the uuid crate
• validate A simple struct validation library
• validate_derive Validation derive macros library
• zip A minimal replacement for the zip crate

Crypto

• digest A minimal replacement for the digest crate
• getrandom A minimal replacement for the getrandom crate
• hmac A minimal replacement for the hmac crate
• pbkdf2 A PBKDF2-HMAC-SHA256 password hashing library
• sha1 A minimal replacement for the sha1 crate
• sha2 A minimal replacement for the sha2 crate

System

• copy_dir A minimal replacement for the copy_dir crate
• directories A minimal replacement for the directories crate
• enable-ansi-support A minimal replacement for the enable-ansi-support crate
• jni A minimal replacement for the jni crate
• keyring A minimal replacement for the keyring crate
• preferences Minimal native shared preferences for desktop and mobile
• rusb A minimal replacement for the rusb crate
• simple_logger A minimal replacement for the simple_logger crate
• terminal_size A minimal replacement for the terminal_size crate
• threadpool A fixed and scalable thread pool for Rust

Languages

• js A WIP JavaScript interpreter

Build

• openapi-generator A simple OpenAPI code generator
• cargo-bundle-assets Embed assets in standalone binaries or load files packaged by cargo-bundle
• rust-embed A minimal replacement for the rust-embed crate
• rust-embed-impl A minimal replacement for the rust-embed-impl crate
• winresource A minimal replacement for the winresource crate

Testing

• criterion A minimal replacement for the criterion crate
• trybuild A minimal replacement for the trybuild crate

Getting Started

• Install Rust, Node.js, Hadolint, a C toolchain (such as GCC, Clang or MSVC), an LLVM toolchain, clang-format, NASM and Dolphin emulator

• Install Rust nightly toolchain, cargo-binstall, cargo-deny and cargo-nextest:

  rustup toolchain add nightly --component rust-src --component rustfmt
  cargo install cargo-binstall
  cargo binstall -y --locked cargo-deny cargo-nextest
  

• Run checks, or run an example:

  cargo xtask check
  cargo run --bin example-persons-api
  cargo run --bin example-todo-app
  

Additional tools

• Run the local criterion benchmarks with:

  cargo bench -p base64 --bench base64
  cargo bench -p crc --bench crc
  cargo bench -p image --bench image
  cargo bench -p sha2 --bench sha2
  

• For coverage reports, install the llvm-tools and cargo-llvm-cov tool:

  rustup component add llvm-tools
  cargo binstall -y --locked cargo-llvm-cov
  cargo xtask coverage
  

• To build pages, install a wasm target and the wasm-bindgen-cli tool:

  rustup target add wasm32-unknown-unknown
  cargo binstall -y --locked wasm-bindgen-cli --version 0.2.129
  cargo xtask build-pages
  

• To build app bundles, install the targets below, on Windows this builds MSIX bundles with the Windows SDK and MSVC build tools for x64 and ARM64:

  rustup target add aarch64-apple-darwin x86_64-apple-darwin # macOS
  rustup target add aarch64-pc-windows-msvc x86_64-pc-windows-msvc # Windows
  cargo xtask build-bundle
  

• To build and install bins and GUI applications to your system, on Windows this installs the MSIX packages after one UAC prompt:

  cargo xtask install
  

• To build and install the iOS applications on the booted iOS simulators:

  rustup target add aarch64-apple-ios-sim
  cargo xtask install-ios
  

• To build and install the Android applications on the first connected adb device or emulator, with the Android SDK, NDK and JDK 17 or 21 installed:

  rustup target add armv7-linux-androideabi aarch64-linux-android x86_64-linux-android
  cargo xtask install-android
  

Goals

This project is driven by three main goals:

1. A self-written minimal crates collection for backend software

Rather than pulling in large, general-purpose dependencies, this repo grows a curated set of small, focused libraries that cover exactly what is needed - nothing more. This includes an HTTP/1.1 server, a router, a SQLite and MySQL library, validation, password hashing, UUID generation, and more. Many of these are intentional minimal replacements for well-known crates on crates.io, rewritten from scratch to be lean, auditable, and free of transitive dependencies.

2. A minimal Electron/Tauri-like desktop platform

bwebview is a cross-platform native webview library that lets you ship desktop applications using web technologies, without the weight of bundling a full browser engine. It uses the system-native webview on each platform (WebKit on macOS/iOS, WebView2 on Windows, WebKitGTK on Linux, WebView on Android) and exposes a small, clean Rust API. The desktop apps and games in this repo, like a SQLite and MySQL viewer, a pixel font editor, a man page browser and a 2048 game, show that this works in practice.

3. Tools and a custom build system for complex multi-language projects

Building projects that span multiple languages and artifact types (Rust, JavaScript, WASM, native bundles) requires coordination that general-purpose build systems handle poorly. bob is a minimal build system inspired by Cargo's simplicity, designed to describe and orchestrate such projects cleanly. cargo-bundle handles macOS and iOS .app bundle, Windows .msix and Android .apk packaging from within the Cargo ecosystem. Together with the xtask crate these tools keep the build pipeline typed, cross-platform and easy to follow.

Repo organization

This repo is a monorepo. Projects are grouped by what they are, not by the language they are written in:

• apps - applications, grouped by platform: desktop for cross-platform apps, plus macos, windows and web
• examples - standalone examples, grouped by platform
• games - games and their engines
• lib - libraries, grouped by topic like ui, graphics, net, data and crypto
• tools - developer tools, including the build tooling of this repo

Library examples live next to the library they show off, in its examples directory. Standalone platform examples live under the top-level examples directory.

The main Rust projects share one Cargo workspace and the JavaScript projects share one npm workspace. The macOS and iOS Rust examples are standalone projects using the local Apple bindings. The Wii Rust examples are standalone nightly projects with a custom PowerPC target. When a Rust app has a web frontend, its Cargo build script runs npm for you, so Cargo stays the one place where everything comes together.

Every top-level task, like checking, building and installing, goes through the xtask crate with cargo xtask, both on your machine and in CI.

License

Copyright © 2019-2026 Bastiaan van der Plaat

Licensed under the MIT license.