Mibo 1.0.0

There is a newer version of this package available.
See the version list below for details.
dotnet add package Mibo --version 1.0.0
                    
NuGet\Install-Package Mibo -Version 1.0.0
                    
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Mibo" Version="1.0.0" />
                    
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="Mibo" Version="1.0.0" />
                    
Directory.Packages.props
<PackageReference Include="Mibo" />
                    
Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add Mibo --version 1.0.0
                    
#r "nuget: Mibo, 1.0.0"
                    
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package Mibo@1.0.0
                    
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=Mibo&version=1.0.0
                    
Install as a Cake Addin
#tool nuget:?package=Mibo&version=1.0.0
                    
Install as a Cake Tool

Mibo

Mibo is a lightweight, Elmish-inspired micro-framework for F# that helps you build games on top of MonoGame (the underlying game framework). It’s designed to stay fun for small games while still providing an upgrade path for bigger projects (ARPG/RTS-style complexity) without forcing you to rewrite your engine.

Key ideas:

  • Keep update pure (MVU)
  • Submit render commands to a RenderBuffer in view
  • Use explicit boundaries (tick ownership, phases, snapshot barriers) when scaling up

If you prefer learning by example, check out the working sample projects:

  • src/Sample (2D sample)
  • src/3DSample (3D sample)

What’s in the box?

  • Elmish runtime for MonoGame games (MVU loop)
    • optional fixed timestep support
    • optional frame-bounded dispatch for stricter frame boundaries
  • Input (raw input + semantic mapping / rebinding-friendly)
  • Assets (loading + caching helpers)
  • Rendering
    • 2D SpriteBatch renderer (layers + multi-camera amenities)
    • 3D renderer with opaque/transparent passes + multi-camera amenities
    • Sprite3D “90% path” for unlit textured quads and billboards
    • escape hatches (DrawCustom) when you need custom GPU work
  • Camera helpers + culling utilities

Documentation

The docs live in docs/ and are intended to be the authoritative reference.

Start here:

  • Architecture
    • Elmish runtime: docs/elmish.md
    • System pipeline (phases + snapshot): docs/system.md
    • Scaling ladder (Simple → Complex): docs/scaling.md
  • Core services
    • Input: docs/input.md
    • Assets: docs/assets.md
  • Rendering
    • Overview / composition: docs/rendering.md
    • 2D: docs/rendering2d.md
    • 3D: docs/rendering3d.md
    • Camera: docs/camera.md

Getting started (Windows)

Prerequisites:

  • .NET SDK 10 (the samples target net10.0)
  • A working OpenGL setup (MonoGame DesktopGL)

From the repo root:

dotnet --version
dotnet tool restore
dotnet restore
dotnet build
dotnet test

Run the samples

2D sample:

dotnet run --project .\src\Sample\MiboSample.fsproj

3D sample:

dotnet run --project .\src\3DSample\3DSample.fsproj

Content pipeline tooling

This repo uses local dotnet tools (see .config/dotnet-tools.json) for MonoGame content:

  • mgcb / mgcb-editor-*

If you need to edit a content project:

dotnet tool restore
dotnet mgcb-editor-windows

Build the documentation site (optional)

The repo uses fsdocs-tool.

dotnet tool restore
dotnet fsdocs build

To watch locally while editing:

dotnet tool restore
dotnet fsdocs watch

Repo structure

  • src/Mibo — the core framework library
  • src/Mibo.Tests — unit tests
  • src/Sample — 2D sample game
  • src/3DSample — 3D sample game
  • docs/ — documentation source

Feedback welcome

If you’re interested in using F# beyond simple 2D games—while still staying in the MonoGame ecosystem—issues and PRs are very welcome.

Product Compatible and additional computed target framework versions.
.NET net8.0 is compatible.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed.  net9.0 was computed.  net9.0-android was computed.  net9.0-browser was computed.  net9.0-ios was computed.  net9.0-maccatalyst was computed.  net9.0-macos was computed.  net9.0-tvos was computed.  net9.0-windows was computed.  net10.0 was computed.  net10.0-android was computed.  net10.0-browser was computed.  net10.0-ios was computed.  net10.0-maccatalyst was computed.  net10.0-macos was computed.  net10.0-tvos was computed.  net10.0-windows was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
1.6.0 103 2/8/2026
1.5.1 95 1/29/2026
1.5.0 100 1/25/2026
1.4.0 91 1/20/2026
1.3.0 95 1/19/2026
1.2.0 100 1/11/2026
1.1.0 98 1/10/2026
1.0.1 94 1/9/2026
1.0.0 97 1/9/2026

### Added

- Changed something in the package
- Updated the target framework
- Core: `ElmishGame` runtime loop integrating Elmish architecture with MonoGame lifecycle.
- Core: `Program` module for configuring init, update, renderers, and services.
- System: `System` pipeline for organizing frame logic into mutable and read-only phases (`pipeMutable`, `snapshot`, `pipe`).
- Input: Reactive `Input` service for Keyboard, Mouse, Touch, and Gamepad polling.
- Input: `InputMapper` for binding hardware triggers to semantic Game Actions.
- Input: Subscription helpers (`Keyboard`, `Mouse`, `Gamepad`, `Touch`) for Elmish event handling.
- Rendering: `RenderBuffer` for allocation-friendly command sorting and batching.
- Rendering: `Batch2DRenderer` for layer-sorted 2D sprite rendering.
- Rendering: `Camera2D` with viewport bounds and screen-to-world conversion.
- Rendering: `Batch3DRenderer` supporting `BasicEffect`, `SkinnedEffect`, and custom effects.
- Rendering: `Camera3D` with perspective/orbit modes, raycasting, and frustum generation.
- Rendering: Specialized batchers for 3D Sprites (`BillboardBatch`, `SpriteQuadBatch`) and Quads.
- Assets: `IAssets` service for loading and caching Textures, Models, Fonts, and Sounds.
- Time: `FixedStep` configuration for deterministic physics/simulation steps.
- Math: `Culling` module for frustum containment checks.