# Announcing TinyFFR v1.0: A highish-level C# 3D realtime rendering library (NOT vibe slop!) — retained record

> Retained reddit record from reddit:gamedev.

Canonical: https://highsignal.app/data/records/a7ce338d00b6707b

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:gamedev)  published 2026-10-19 09:43 ingested 2026-10-20 02:37

[original source ↗](https://www.reddit.com/r/gamedev/comments/1x9siay/announcing_tinyffr_v10_a_highishlevel_c_3d/)

## retained text



```
## Intro: The Why of TinyFFR

C# has some really great libraries for anyone who likes the "build your own engine" approach; for physics you have BepuPhysics or Jitter2, audio has OpenAL or SoundFlow (and a couple others), networking has LiteNetLib, Riptide, ENet-CSharp, and probably some more I'm forgetting right now.

However... When it comes to 3D graphics in my opinion the options have always felt limited; there are mostly only managed wrappers over raw graphics APIs that still require you to do the hardest parts of a 3D render pipeline yourself. I see this as a significant gap in the gamedev ecosystem and it's something that's frustrated me personally for a long time, so I set out to fix it.

That's basically where TinyFFR comes in. It's a single C# library (available via NuGet) that gives you everything you need to render modern realtime 3D without having to touch shaders or graphics APIs at all. It won't be for everyone of course: Some people will surely continue to prefer the flexibility of writing against graphics APIs themselves, but for anyone who wants to build a 3D game/app and just wants a modern plug-and-play PBR renderer, TinyFFR is for you!

## TinyFFR Features

TinyFFR is free, targets cross-platform desktop (Windows, Linux w/ Wayland, MacOS Apple Silicon) and open-source^(†). It provides the following features OOTB:

* A PBR material system ready-to-go;
* State-of-the-art render pipeline: Forward+ rendering, VSM shadowing, FXAA + TAA antialiasing, AMD FidelityFX (FSR) upscaling, physical post-processing (incl. HDR bloom, DoF, fog, shadowing, real exposure), image-based-lighting;
* Support for tens of model formats (incl. glTF + GLB, OBJ, FBX, STL, STEP/STP, + more);
* SDF text rendering (both for 2D canvases and 3D in-world)- supports any TTF file and has three fonts built-in;
* Skeletal animation (including anim blending + node transform calculations);
* ImGui, Avalonia, WPF, and WinForms integration;
* Scene compositing: Render-to-texture, picture-in-picture, splitscreen, render-to-bitmap. Multi-scene, multi-camera setups as standard;
* Camera controllers (first-person, follow/chase, free-flying, inspection, orbital, PTZ, programmable keyframe);
* Dynamic vertex buffers, dynamic textures + parallelized mutation APIs for both;
* Scene querying (pixel picking, ray testing, shape testing);
* Fully documented (every public member has xmldoc, NOT AI slop; and the main site has lots of documentation, also not AI slop);
* A really rich plain-English math API;
* A window + input API with intrinsic support/understanding of DPI scaling on all three platforms.

**†**: The source is [available on github](https://github.com/Egodystonic/TinyFFR/); the library uses a modified FSL license that converts to MIT after two years.

## Performance & Additional Work

I have a background in engine dev + high-performance C#, having previously released a game on Steam under a custom C# engine and also worked in the energy industry writing grid-scale battery management servers. For TinyFFR I've transferred that knowledge and gone to extreme lengths to prioritise performance:

* No GC stutter whatsoever. Completely flatline memory profile throughout the entire application lifetime (asset loading, render/frame loop, input, windowing, streaming, etc). Zero GC allocation target verified by a Benchmark.NET benchmark suite, plus API helpers exposed that make it easy for user code to avoid creating GC pressure;
* AoT publish ready (no dynamic access or reflection throughout);
* SIMD-enabled math lib;
* Custom allocators for pooled memory re-use, including a [slab allocator](https://github.com/Egodystonic/TinyFFR/blob/90fb1aebf7d4bfd595a7ee77ea15b81a0b32d0fd/TinyFFR/Resources/Memory/FixedByteSlabPool.cs), custom [zero-GC collections](https://github.com/Egodystonic/TinyFFR/blob/90fb1aebf7d4bfd595a7ee77ea15b81a0b32d0fd/TinyFFR/Threading/ArrayPoolBackedConcurrentBlockingQueue.cs), native interop [string buffers](https://github.com/Egodystonic/TinyFFR/blob/90fb1aebf7d4bfd595a7ee77ea15b81a0b32d0fd/TinyFFR/Util/Interop/InteropStringBuffer.cs), and bespoke [array pools](https://github.com/Egodystonic/TinyFFR/blob/90fb1aebf7d4bfd595a7ee77ea15b81a0b32d0fd/TinyFFR/Resources/Memory/TinyFfrArrayPool.cs);
* Zero-GC, block-based, [lock-free parallelization](https://github.com/Egodystonic/TinyFFR/blob/90fb1aebf7d4bfd595a7ee77ea15b81a0b32d0fd/TinyFFR/Threading/ParallelizationProvider.cs), accessible to users and used internally throughout for things like mesh mutations and texture compression;
* Upscaled resolution options, copious render quality tweaks including frame latency controls, buffer reduction + vsync;
* Asset bakery for fast loading;
* Tons of [caching](https://github.com/Egodystonic/TinyFFR/blob/90fb1aebf7d4bfd595a7ee77ea15b81a0b32d0fd/TinyFFR/Assets/Text/LocalFontLoader.cs#L49) or precalculation where possible;
* Hand-optimised algorithms everywhere: [Example 1](https://github.com/Egodystonic/TinyFFR/blob/90fb1aebf7d4bfd595a7ee77ea15b81a0b32d0fd/TinyFFR/Util/InterpolationAlgorithm.cs#L383), [Example 2](https://github.com/Egodystonic/TinyFFR/blob/90fb1aebf7d4bfd595a7ee77ea15b81a0b32d0fd/TinyFFR/Assets/Meshes/Local/SkeletalMeshUtils.cs#L22), [Example 3](https://github.com/Egodystonic/TinyFFR/blob/90fb1aebf7d4bfd595a7ee77ea15b81a0b32d0fd/TinyFFR/Math/Geometry/Orientation.cs#L516)

On my 3080Ti, I can run the [voxel world generator example](https://github.com/Egodystonic/TinyFFR/tree/main/Examples/VoxelWorld) at **native 4K 'High'** settings at just under *400FPS*, or on **'Very Low' at 67% native res (~2572x1447 FSR upscaled to 4K)** at *800-900FPS*. That's with a realtime voxel terrain generator running inside it too.

## What Next?

I've been working on TinyFFR as a passion project for about three years, and I'm now ready to open it up to a wider audience. I have a lot of ideas about next steps so I'm looking to build a small community that I can work with to prioritise/inform how to continue developing it.

If you're interested, please consider joining my [discord server](https://discord.gg/5vMDq7znwj). 

There's also a website here with loads of reference guides + tutorials: https://tinyffr.dev

And finally, here are some screenshots made with the library (taken from the video on the [homepage](https://tinyffr.dev)):

[Screenshot 1](https://tinyffr.dev/index_category_4.jpg)
[Screenshot 2](https://tinyffr.dev/index_category_1.jpg)
[Screenshot 3](https://tinyffr.dev/index_category_2.jpg)
```



document fetched 2026-10-20 00:26 · canonical https://reddit.com/r/gamedev/comments/1x9siay/announcing_tinyffr_v10_a_highishlevel_c_3d
