Notes

// a digital garden — expect seedlings

This is the lower-friction companion to my experiment write-ups. It collects learning logs, reference pages, and half-formed thoughts about rendering, geometry, and typed languages. Some will grow into proper articles; most will stay small. That is the point.

Start here

• Marching Cubes — the algorithm behind Raym
• From brush stroke to mesh — how Raym turns an edit into a local mesh update
• Ray marching and SDFs — signed-distance geometry and sphere tracing
• Voxel rendering techniques — a map of the main ways to render voxel data
• OCaml - learning log — notes from exploring another strongly typed functional language
• How this site works — Obsidian Publish, the dithered distance field, and publishing guardrails

Conventions

Each note carries a status in its frontmatter:

• seedling — a raw thought or fresh note. May be wrong, will change.
• budding — has some shape, still evolving.
• evergreen — stable reference I'd point someone to.

Cross-linking is encouraged. If you spot something broken, that's the garden being a garden.

Index

Languages

• OCaml - learning log — seedling · notes and gotchas from picking up OCaml
• OCaml Modules vs Rust Traits vs Haskell Typeclasses — seedling · three approaches to abstraction, compared without pretending they are equivalent
• Algebraic Effects in OCaml 5, From a Haskell and Rust Perspective — seedling · effect handlers through two familiar points of reference
• GADTs Through a Small Typed Expression Evaluator — seedling · making impossible evaluator states unrepresentable
• What Building an Interpreter Teaches About Type Design — seedling · lessons from tokens, ASTs, values, and errors
• Functional Reactive Programming, Ten Years After Flappy Bird — seedling · revisiting signals, events, and Yampa with a decade of hindsight

Colophon

• How this site works — evergreen · the Markdown, design, and publishing system behind this site

3D rendering — fundamentals

• Ray marching and SDFs — budding · sphere tracing, signed distance functions, and the tricks that make them sing
• Physically Based Rendering — seedling · microfacet BRDF, metal/dielectric split, IBL, linear colour
• Shadow mapping — seedling · depth-texture shadows, biasing, CSM, PCF, PCSS
• Deferred vs forward rendering — seedling · where shading happens and what it costs
• Spatial acceleration structures — seedling · BVH, k-d tree, octree, uniform grid
• Normals for Implicit Surfaces — seedling · triangle normals, field gradients, and what shading reveals
• Ray Picking Through the Rendering Pipeline — seedling · unprojecting a cursor into a useful world-space ray
• Real-Time Anti-Aliasing - MSAA, FXAA, SMAA, and TAA — seedling · four families of trade-offs for stable edges

Voxels

• Voxel rendering techniques — budding · survey of how voxel data gets to pixels
• Marching Cubes — budding · the 1987 iso-surface classic
• Dual Contouring — seedling · iso-surface extraction that keeps sharp features
• Sparse Voxel Octrees — budding · compressing and ray-casting through octree worlds
• Designing Scalar Fields for Procedural Terrain — seedling · composing terrain, caves, and edits as fields
• Seamless Chunked Voxel Terrain — seedling · ownership, ghost samples, normals, and crack-free remeshing
• Transvoxel in Practice — seedling · transition cells for mixed-resolution terrain

Building Raym

• From brush stroke to mesh — seedling · ray hit, density edit, dirty chunks, remesh, upload
• Designing Scalar Fields for Procedural Terrain — seedling · the data that exists before Marching Cubes sees a cell
• Seamless Chunked Voxel Terrain — seedling · keeping independently rebuilt chunks continuous
• Marching Cubes on the GPU - Count, Scan, Emit — seedling · variable-length mesh generation as a compute pipeline
• Normals for Implicit Surfaces — seedling · choosing a normal that survives sculpting and lighting
• Transvoxel in Practice — seedling · joining terrain chunks across LOD boundaries

Graphics APIs

• OpenGL - learning log — seedling · modern core-profile OpenGL, DSA, state-machine pitfalls
• Vulkan - learning log — seedling · explicit pipelines, memory, synchronisation
• Compute shaders — seedling · workgroups, shared memory, subgroup ops, where compute shines
• Raylib 3D rendering — budding · raylib's 3D side — cameras, meshes, shaders, rlgl
• Marching Cubes on the GPU - Count, Scan, Emit — seedling · count, prefix-scan, and compact triangle emission
• GPU-Driven Visibility for Large Worlds — seedling · frustum, occlusion, compaction, and indirect draws
• Debugging Graphics Without Guessing — seedling · validation, captures, debug views, and tiny reproducible scenes

Rendering practice

• Ray Picking Through the Rendering Pipeline — turn a screen position into a world-space query
• GPU-Driven Visibility for Large Worlds — decide what is worth submitting before drawing it
• Real-Time Anti-Aliasing - MSAA, FXAA, SMAA, and TAA — understand where spatial and temporal approaches trade quality for cost
• Debugging Graphics Without Guessing — replace visual guesswork with captures and purpose-built views

Guided paths

Graphics lab

1. Start with Raym.
2. Follow an edit through the terrain editing loop.
3. Build the field with Designing Scalar Fields for Procedural Terrain, then extract it with Marching Cubes, Dual Contouring, or Ray marching and SDFs.
4. Make chunks agree with Seamless Chunked Voxel Terrain, Normals for Implicit Surfaces, and Transvoxel in Practice.
5. Add light with Physically Based Rendering, Shadow mapping, and Deferred vs forward rendering, then tame edges with real-time anti-aliasing.
6. Move the work to the GPU with Compute shaders, GPU Marching Cubes, OpenGL, and Vulkan.
7. Scale the world with Spatial acceleration structures, Sparse Voxel Octrees, and GPU-driven visibility.
8. When the picture lies, reach for Debugging Graphics Without Guessing.

Typed languages lab

Start with the Monkey interpreter and its type-design lessons. Continue through the Haskell projects and the FRP retrospective, then follow the OCaml - learning log, compare abstraction across three languages, and finish with GADTs and effect handlers.

Back to Home · explore Experiments · browse Reading.