Brutal Framework Ships 25-Plus Samples, Still No Documentation

The Brutal C# game development framework, released free and open source earlier this month, has added a large batch of runnable samples — while still shipping no documentation. The gap between the two is deliberate: the framework's own team states that the name is a warning, and that "BRUTAL is intended for experienced programmers who want to make their own architectural decisions and are prepared to build and maintain the systems their games require."

At launch, Brutal offered nothing beyond the codebase itself: no documentation, no examples, nothing. Developers had to read the source to figure anything out. That has now changed on one front. The samples cover the framework's full surface — low-level memory, concurrency, graphics, audio, physics and networking — and contributions remain assessed against the team's stated purpose of prioritizing low-level functionality for demanding games.

What do the samples actually demonstrate?

The core samples introduce Brutal's unmanaged-memory programming model (manual allocation of memory outside C#'s garbage collector):

• HelloCore.cs — platform detection, ByteSize/ElementCount arithmetic and Ptr
• HelloMemory.cs — allocating and freeing unmanaged memory with Mem, and owning a pointer with PtrOwner
• HelloCollections.cs — NativeList
• HelloStrings.cs — UTF-8 text with String8 and StringBuilder
• HelloNumerics.cs and HelloMaths.cs — vector and matrix basics with float3 and float4x4, plus Random extensions for ranges, points in shapes and random directions
• HelloConcurrency.cs — running jobs across worker threads with JobScheduler
• HelloLogging.cs and HelloLocalization.cs — console logging with default and named categories, and localized strings with named variables and translation swapping

Samples also exist for windowing, UI and diagnostics, per the framework's sample listing.

Which middleware integrations are covered?

The asset and audio samples show Brutal's bindings to established native libraries:

• Graphics and textures — HelloStb.cs (writing and reading PNG with stb_image), HelloTexture.cs (texture format descriptors, GenericTexture fill, PNG and KTX2 save/load via TextureWriter and TextureLoader), HelloKtx.cs, HelloGli.cs (full mip chain saved and loaded as DDS with GLI), HelloGltf.cs (parsing an inline glTF, reading vertices, saving it back) and HelloMeshOptimizer.cs (reordering triangles for the vertex cache with meshoptimizer)
• Audio — generated tones via OpenAL, Sdl.Mixer and FMOD; FMOD's native libraries are not bundled, so developers need their own licensed copy
• Physics — dropping a box onto the ground and printing where it lands, with both Box2D and Jolt Physics
• Networking — a RakNet server and client connecting over localhost and sending a message

In plain words, the middleware list covers the standard stack a demanding 2D and 3D game would need, with two physics engines and three audio backends to choose from.

What do the full demos show?

The demos assemble the samples' building blocks into complete rendering scenarios:

• DemoVulkan.cs — a colored triangle with Vulkan, the Vulkan.Abstractions helpers, a VMA-allocated vertex buffer and shaders compiled with ShaderC
• DemoGltfViewer.cs — loading a glTF scene with node transforms, optimizing it with meshoptimizer and drawing it lit with OpenGL; accepts a user-supplied .gltf or .glb, or builds a torus knot
• DemoTexturedQuad.cs — writing a mipmapped KTX2 texture, reloading it and drawing it on a floor with each mip level tinted
• DemoImGui.cs — Dear ImGui with FreeType fonts and an ImPlot plot, on GLFW and OpenGL
• DemoSdl.cs — an SDL window with Sdl.Image, Sdl.Mixer and Sdl.Ttf
• DemoRenderDoc.cs — an OpenGL triangle that captures a frame with RenderDoc on F12 (Windows and Linux)
• DemoBox2D.cs and DemoJolt.cs — boxes falling onto the ground with Box2D in 2D and Jolt in 3D, both drawn with OpenGL

A community-created example, available separately, goes further and showcases a full Vulkan renderer implementation for a 3D model loader — an early signal that Brutal is attracting third-party contributors despite its no-handholding posture.

Does this change the framework's positioning?

Not fundamentally. Brutal remains a framework whose scope is deliberately focused, aimed at experienced programmers willing to own their architecture and systems. The samples reduce the cost of evaluating that trade-off; they do not remove it. There is still no documentation, so source-level reading remains the primary path to fluency, and the arrival of community samples suggests the first external contributions are following the team's low-level-focused contribution bar.

The question worth watching is whether documentation follows the samples — until it does, Brutal's effective audience stays limited to engineers comfortable learning from code alone.