Back to portfolio

Personal project / Engine & tools programming

Hibou Engine

A personal game engine where I explore C++ and C# interoperability, editor tooling and the systems underneath a game.

  • C++
  • C#
  • Windows
  • OpenGL
  • WPF
Hibou Engine editor with a 3D viewport, scene hierarchy and component panels.
The Hibou Engine editor, developed alongside the engine.

01 / Context

Learning by building
the layer underneath.

I work on Hibou in my free time to understand how native systems and a managed editor fit together.

The starting point was C++ and C# interoperability. From there, the project became a place to explore rendering, entities and components, project persistence and tools for working with a scene.

I prioritize editor tools and the connection between the two languages. That choice also shapes the renderer: enough to work with a scene while I focus on the systems I want to understand.

02 / Technical decisions

A look inside
the engine and editor.

Hibou Engine editor displaying a scene in its OpenGL viewport.
Working with a scene in the editor.

Rendering

A renderer built with OpenGL

The engine uses OpenGL for rendering. I chose it for simplicity and a relatively quick implementation, so I could concentrate on editor tools and C++ / C# interoperability instead of pursuing photorealistic graphics.

  • C++
  • OpenGL
The WPF-based Hibou Engine editor interface.
The managed editor interface.

Editor tooling

A managed editor with WPF

The editor interface is built with Windows Presentation Foundation (WPF). It gives me a Windows UI foundation for developing scene tools and exploring interfaces such as node editors alongside the native engine.

  • C#
  • WPF
  • Windows
A project open in the Hibou Engine editor.
Project data and scene editing.

Project persistence

Projects and serialization

Each project is handled independently. Scenes, entities, components and settings are serialized so a project can be saved and loaded. This is part of making the editor useful across separate working sessions.

  • Scenes
  • Components
  • Serialization
Scene hierarchy and component panels in Hibou Engine.
Entities and components represented in the editor.

Engine architecture

Entities and components with EnTT

The engine core uses an entity-component-system (ECS) architecture with EnTT. It is where I explore how entities and components are represented underneath the editor.

  • C++
  • EnTT
  • ECS

03 / Under the hood

Building the project.
Working with memory.

Build configuration

Generating projects with Sharpmake

Project and solution files are generated programmatically with Sharpmake, Ubisoft's open-source C# build configuration tool.

Hibou Engine build configuration written with Sharpmake.
Build configuration in code.

Memory / In progress

Exploring EASTL

I'm progressively replacing parts of the standard C++ library with Electronic Arts' EASTL to explore finer control over memory allocation in engine systems.

This is ongoing work. The focus here is the implementation and the choices involved.

  • C++
  • EASTL
  • Memory allocation

04 / Work in progress

Exploring
visual scripting.

In development

The next goal is a node-based system for authoring gameplay logic.

The UI foundation uses Nodify. My current focus is the underlying graph model and logic execution: how a graph authored in the editor becomes logic that runs.

This is a direction I'm exploring in the project, rather than a finished feature.

  • C#
  • Nodify
  • Graph model
  • Gameplay logic

Contact

Québec City, QC, Canada / Available for opportunities

I'm open to opportunities in software development, tools programming and gameplay programming, as well as junior 3D artist roles. If my experience could be a good fit for your team, I'd be happy to connect through my social profiles.