Mutability as a First-Class Concept: The Lattice Phase System
How Lattice treats mutability as a runtime-observable, constrainable, and reactive property — moving beyond const/let into a full lifecycle system for data state.
TinyComputers.io
Sponsors
Recent Articles
Porting CP/M to the Arduino Giga R1: When Level Converters Fight Back
Porting CP/M 2.2 from an Arduino Mega to the Giga R1 WiFi turned into a deep dive on TXB0108 level converter failures, shadow register tracking, and building a Rust sector server for WiFi-based disk I/O.
Milk-V Mars Review: SiFive's RISC-V Enters the SBC Arena
Comprehensive review and benchmark analysis of the Milk-V Mars, a RISC-V single board computer powered by the StarFive JH7110 SoC with four SiFive U74-MC cores and 8GB RAM. Rust compilation benchmarks reveal it's the slowest board in our test fleet at 936 seconds average, but the board tells an important story about RISC-V's current state and the architectural diversity emerging in the SBC market.
Introducing Lattice: A Crystallization-Based Programming Language
An introduction to Lattice, a new programming language built around a novel crystallization-based phase system for managing mutability and memory. This post explores how Lattice's flux/fix/freeze/thaw/forge model differs from existing approaches like Rust's ownership, garbage collection, and traditional immutability, and why treating variable mutability as a physical phase transition leads to clearer, safer programs.
SectorZ: A C Compiler in 733 Bytes of Z80 Assembly
A tiny C compiler written entirely in Z80 assembly that reads source code over serial and generates executable Z80 machine code, inspired by SectorC's 512-byte x86-16 compiler.
Review of "Getting Started with FPGAs" by Russell Merrick
A comprehensive review of "Getting Started with FPGAs: Digital Circuit Design, Verilog, and VHDL for Beginners" by Russell Merrick, published by No Starch Press. This book provides an accessible on-ramp to field programmable gate array development, covering Boolean algebra, flip-flops, simulation, state machines, FPGA primitives, binary math, and I/O through hands-on projects targeting Lattice iCE40 hardware. Merrick's dual-language approach presenting every code example in both Verilog and VHDL, combined with his years of educational content creation at nandland.com, produces a uniquely approachable beginner text that demystifies the parallel-thinking paradigm shift required for hardware description.
Three Paths to Rust on Custom Hardware
There are multiple ways to get Rust running on custom or retro CPUs. This article explores three approaches—full LLVM backends, Rust-to-C transpilation via Eurydice, and manual no_std FFI—with a practical walkthrough of transpiling Rust to C and compiling it for the Z80 with SDCC.
The Z-80 Microcomputer Handbook: A 1978 Reference That Outlived Its Era
A review of William Barden Jr.'s 1978 classic "The Z-80 Microcomputer Handbook" - a comprehensive technical reference that covered hardware, software, and complete microcomputer systems built around Zilog's iconic Z80 processor.
Partial LLM Loading: Running Models Too Big for VRAM
An exploration of techniques for running large language models that exceed your GPU's VRAM capacity by loading only portions of the model at a time—layer streaming, CPU offloading, and the performance trade-offs involved.
Part 3: Building an LLVM Backend for Sampo - Rust Runs on a Custom 16-bit RISC CPU
A detailed account of implementing a complete LLVM backend for the Sampo 16-bit RISC CPU, enabling Rust compilation. This project demonstrates how AI-assisted development with Claude Code can tackle complex compiler engineering challenges.