EN PT-BR

We make the engine, the renderer, the tools, the anti‑cheat and the game.

Eight years building one layer at a time, from bottom to top. None of them are rented, none are black boxes: each one opens on our machine, in a file that we wrote.

Engine
UnderWar Engine
Graphics
UnderRender
Protection
UnderProtection
Tool
UnderStudio
Game
Dread Thicket

The stack

Our technology, end to end

It is not a licensed engine with plugins on top. It's a stack of technologies that are known, written here, versioned here, fixed here — and they all live within the same executable.

UnderStudio— the tool, and the studio
  • ├── UnderWar Engine — the engine: world, physics, sound, network, console
  • ├── UnderRender UnderRenderNEW — the graphics runtime on DirectX 9
  • ├── UnderProtection — the anti-cheat, from the six layers to the review panel
  • └── UnderTools — packer, launcher, character mat, location

And what comes out of it: Dread Thicket — the survival game that runs on top of all four, and that tests each one with real people inside.

The studio

Since 2018 on the same project, building layer by layer

It's been eight years of stacking up: first what made the game run, then what made it playable by someone else, then what kept it standing with people inside. In that order, because you can't skip this step — a map generator is useless until there is an editor that opens the generated map.

Small studios don’t usually have this option. The normal path is to license an engine, accept someone else's decisions, and wait for the next version when something doesn't fit. We went the other way, and that has a price: a tool that comes free in a commercial engine, here we write. We write.

The payoff is that none of our game is black box. When something is wrong, there is always a file to open — and it's not just any file: it's one that passed through our hands.

  • The entire anti-cheat, from scratchWe do not integrate detection of anyone. The six layers—client-side agent, native brain, server-side authority, telemetry, batch analysis, and human review—are our design and code.
  • The graphics runtimeUnderRender: the layer that draws, separated from the rest of the client. Compatibility with the existing DirectX 9 pipeline on one side, modern pipeline on the other.
  • The game interface, screen by screenOwn system of components, screens described in a data file, our own visual editor and hot reloading — changing a screen doesn't require recompiling anything.
  • The world generatorRelief with erosion, network of rivers, network of streets, blocks, lots, buildings and vegetation. Each step is an algorithm that we wrote and that runs inside the engine, not a script on the outside.
  • The authoring toolsLevel, physics, particle, character, interface editor and anti-cheat panel — all within the same executable that runs the game.
  • The character treadmillFrom FBX to the character standing in the game, with skeleton, skin and texture converted by our tool, without depending on any third-party program along the way.
  • The backend and payment methodFrom authentication to the purchase flow that runs today, including the player's wallet, transaction history and the webhook that confirms payment.
  • The launcher and distributionInstall, update and check the game on your own, downloading only the part that changed; the version goes up with each build.

The studio and one of our tools have the same name. It's not carelessness - the tool is the studio. This is where the game is built, tested and played.

The technologies

What we built

Five names, and each one depends on the previous one in the order in which they appear.

UnderWar Engine

The engine

World, physics, sound, network and console system. It's the layer that doesn't appear to anyone and that decides everything: how many objects fit into a scene, how long it takes to load a map, whether a shot registers.

Maintained by us, which means optimization is not a resource request to a supplier — it's an afternoon of work in the right file.

The entire stack, and the eighteen subsystems with the file each one lives in, are in the engine section.

UnderRender

UnderRender

The graphical runtime · new

Advanced Graphics Runtime for DirectX 9. The layer that draws, isolated from the rest of the client and treated as an independent technology: the game requests the scene, UnderRender decides how it becomes an image.

The drawing has two sides. From one to compatibility: the entire DirectX 9 pipeline that already exists continues to run, without the game logic knowing that anything has changed. On the other, the modern pipeline, which is where the image improves.

Details and the complete diagram in UnderRender section.

UnderStudio

The tool

A single executable that is the game and the workshop at the same time — the same binary that the player runs is what opens the editor. No exporting to test: press a key and the map you are editing becomes a match.

It's also where the world generator lives. It starts with the relief — erosion and river network — and goes upwards: network of streets, blocks, lots, buildings, street clothing and vegetation. A map grows from a seed and only becomes a playable level after passing a validation battery.

  • Level editor with sticky panels, gizmo and undo history by action type
  • Particle, physics, character and interface editor
  • Anti-cheat panel, with suspect queue and manual review
  • Configuring the game and servers via interface, without editing files
  • Packaging, validation and extraction of distribution files
  • Translation of the entire game, with detection of what still needs to be translated

What is inside each of these fronts is in the tool section.

UnderProtection

The anti-cheat

Built by necessity and maintained by principle: We built UnderProtection on six proprietary layers — client-side agent, native detection brain, server-side authority, match-based telemetry, pattern analysis, and human review. From the first sign to the verdict, the protection is ours.

Today we do not integrate detection of anyone — not a third-party DLL, not an external service, not a signature that we can't read. Whoever controls detection controls the game.

There are six layers, from the agent at the customer to the person who decides. They are open one by one anti-cheat section.

Dread Thicket

The game

Open world survival with PvP and loss of what you carry when you die. It is for him that the four layers above exist, and he is the one who tests each of them — with a server up, people inside and someone trying to cheat.

UnderWar Engine

The engine, completely open

We do not license engines. Ours compiles here, on our machine, with the entire source on the table — and that's why every number in this section could be counted, and not estimated.

The stack, from top to bottom

Application

UnderStudio.exe — the game and editors

Just one binary. The same executable that the player runs is the one that opens the level editor, the particle editor, the character editor, the interface editor and the anti-cheat panel.

Shared logic

GameEngine — the glue between client and server

Objects from the world, artificial intelligence, terrain, physics and sound live here and are compiled within the two sides. It's what ensures that server and client see the same world — the basis of any authoritative anti-cheat.

Core

UnderWar Engine — the engine

Renderer, packaged file system, console and variables, particles, animation, networking, background tasks, memory and profiling. None of this appears to the player, and everything decides how he feels.

Third Parties

External — 22 SDKs, and the lesson that came from them

Physics, sound, network and navigation come from known libraries, versioned within the project. Two of these suppliers ceased to exist halfway through — that's exactly what taught us how to write the rest.

The subsystems, and where each one lives

  • Renderer

    Direct3D 9 with 281 shaders, materials, fonts and post-processing. It's the heart of the engine — and the reason UnderRender exists.

  • Land

    Height grid in megatexture, broken into blocks, with layers of paint, LOD and own collision.

  • Vegetation and rock

    Quadtree collections: tens of thousands of instances with physics created on load, not one by one.

  • Lighting

    Dynamic lights, light probes, cubemap and environment map generated from any point in the scene.

  • Water

    One water plane per body, with height, color, attenuation and waves pre-generated by FFT outside the game.

  • Particles

    Emitters with Bézier curves and time gradient, editable live with pause, step and slow motion.

  • Animation and skin

    Skeleton, skin and animation stack with influence by layer — and the diagnosis visible within the editor.

  • Physical

    Mesh cooked collision, terrain heightfield, ragdoll, triggers and simplified shell for the player.

  • Sound

    3D events with minimum and maximum radius, volume by source and environment defined by level.

  • Network

    Authoritative UDP, with master, supervisor and starting servers open on demand.

  • Navigation

    Navigation mesh and convex regions generated within the editor itself, with name and visualization.

  • File system

    Compressed package with CRC checking, reconstruction, waste measurement, and extraction — and in development, loose file wins over package.

  • Console and variables

    Each variable is registered with type, range and callback. It is this metadata that allows you to configure the game by interface instead of file.

  • Hot refill

    Texture, shader, mesh, animation and configuration reload themselves when the file changes on disk, with a warning on the screen.

  • Background tasks

    Job queue to load, cook and generate without crashing the editor window.

  • Memory and budget

    Own arena allocator, budget meter per category and saved limits per level.

  • Entrance and platform

    Keyboard, mouse and the eight remappable buttons, borderless window and the system layer that holds it all in Windows.

  • Profiling and drop

    Profiler with file export, call stack, native minidump and machine hardware reading.

UnderRender

Advanced Graphics Runtime for DirectX 9

A high-performance graphics runtime designed to extend a DirectX 9 application with modern rendering techniques without breaking the pipeline that already exists.

Old engine has a known problem: the code it draws is scattered throughout the game. Changing the image becomes changing the entire game, and that's why no one changes it. UnderRender exists to undo this — every drawing call passes through one of our layers, and from then on the image is a separate subject from logic.

The compatibility layer is already compiled into the engine. It's the foundation: as long as it responds exactly as DirectX 9 did, the game remains the same — and the modern pipeline can grow behind it without risk.

UnderRender

D3D9 Compatibility

The proof of success is that the image does not change. Each game draw call goes through the layer and comes out identical — same scene, same pixel. It's what allows you to change what's below without anything above noticing.

  • Single drawing layer
  • Golden image
  • Regression by comparison
  • Without touching the game logic

Enhanced Pipeline

This is where the image improves. Lighting, shadow, post-processing and resolution scaling, each linkable by quality level — from the player's old computer to ours.

  • HDR
  • PBR
  • fog
  • LOD
  • SSAO
  • Shadows
  • Tonemap
  • Lighting
  • Bloom
  • SSR
  • AA
  • Upscale

Why this is a technology, not a menu option: When the graphic layer is yours, the quality decision stops being “what the licensed engine allows” and becomes “what we write”. A new effect is a new file, not a request to a vendor.

UnderProtection

Six layers, and the last one is a person

None of them are purchased, licensed or integrated. The six are our project and code, and they change the day they need to change.

  1. 01

    Agent at the customer

    Compiled within the executable itself, without a single DLL: checks the binary signature, looks for a coupled debugger and scans the memory for the injected module — on its own and when the server tells it to scan.

  2. 02

    Native brain, instead of the supplier

    The detection service that this type of game used no longer exists, and its libraries are unobtainable. Instead of accepting dead protection, we rewrite the brain with the same interface and linked static in the executable. The challenge comes from the server, the answer comes from the agent, the verdict is ours.

  3. 03

    Authority on the server

    Where the player cannot reach. Each match is validated against dozens of cheat types — infinite life, flight, speed, shot through wall, tampered weapon, impossible distance, cadence, item appearing out of nowhere, forged recipe, inventory, reload, vehicle — in almost two hundred checkpoints.

  4. 04

    Own telemetry, per game

    Each match records who entered, who killed who, at what distance, in how long and with how many headshots. It's our bank, our format — and it has completely replaced the telemetry service that disappeared.

  5. 05

    Batch analysis

    Outside of the game, the history is crossed looking for patterns that a human would not see in real time. What the analysis produces is not punishment: it is a line of suspects. And, when this is the case, the server even asks the client for a screenshot right away.

  6. 06

    Human review, within the tool

    The queue opens in a panel within UnderStudio itself, with the occurrences and what each one means. The final verdict is always one person's — the machine points out, no one here is banned for a single number.

UnderStudio inside

One executable, the entire workshop

The game opens in a hub. Everything comes from there: the game itself, the editors and the tools that keep the operation going — including those that have nothing to do with editing the map.

  • Level editor

    Fixed panels, in place of modes

    Hierarchy on the left, inspector on the right, console at the bottom — always visible. Object selected in the world lights up in the list, and vice versa. The layout is saved and returns in the next session.

  • Level editor

    Undo that achieves everything

    Thirty-five types of action in history, from the sculpted terrain to the glued object. Atomic save with backup, autosave and restore — lost work is a bug, not a fatality.

  • Level editor

    Find instead of decorate

    Global search, shortcut command palette, click-remappable shortcuts, clickable minimap that flies to the point, and a validator that lists what's wrong on the map — each line takes you to the object.

  • world generation

    A map from a seed

    Relief, network of rivers and lakes, settlements, network of streets, blocks, lots, buildings, street clothing, vegetation, sound and game areas. Seven linked steps, all inside the engine.

  • world generation

    Ruler, not opinion

    Every map generated passes through a gate that measures height, slope, water, density and accessibility — and compares it with a reference map. If you don't pass, you don't become a level.

  • Interface

    Visual editor of game screens

    Each screen is a data file, assembled in an editor within Studio and hot reloaded. Twenty of its own screens already live like this — from the menu to the HUD, from the store to the wallet.

  • Character and animation

    From FBX to gaming

    Mesh, skeleton, skin and texture converted by our mat, with no third-party program in the way. The character editor assembles the doll, changes equipment and shows the game's three cameras.

  • Operation

    Anti-cheat and servers per interface

    Anti-cheat panel with incidents and suspect queue, server configuration without editing files, packaging and distribution verification — the entire operation lives in the same window.

  • Languages

    Portuguese by default

    All text in the game goes through the language system from the first line, in seven packets. The tool shows what still needs to be translated, instead of letting the error appear on the player's face.

How we work

Six rules that we don't break

They cost time to learn and save much more than they cost.

  • Don't outsource what can disappear

    External service that takes functionality along with it. It's happened to us — twice, in anti-cheat — and that's why the protection, interface and telemetry are ours.

  • Read in the code, never deduce from the name

    The role of a file is read where it is carried and used; folder, extension and naming convention are clue, not truth. If the source contradicts the guess, the source wins. We have the entire source for just that.

  • Measure before asserting

    Number that appears in our documents was counted, not estimated. Before and after each change, with the same ruler and the same content on both sides.

  • Portuguese by default

    The game's default language is Brazilian Portuguese, and all text goes through the language system from the first line. Translation is not the final step here.

  • The tool lives inside the engine

    No external script generating content from the outside. If the engine knows how to place an object on the ground, the generator calls the engine — it does not rewrite the calculation in another place, where it will diverge.

  • One layer at a time, the bottom one first

    Tool before content, engine before tool. It's slower at first and that's why today we can generate an entire map from a seed.

Outside the official line

Fan projects

Things that we built out of pleasure. These are fan projects, without any link, sponsorship or approval from any rights holder.

TamerQuest

Fan project · unofficial

Free MMORPG for capturing, training and battling creatures, playable directly in the browser and entirely in Portuguese. It was born as a tribute to the monster taming genre and continues to run on its own server.

Open tamerquest

Dread Thicket opens in pre-beta

Open-world survival running on our entire stack. The pre-beta comes out before the Steam page — you can join the alert list now.

Get the latest news from Dread Thicket

Join the list to receive notice of the pre-beta and the Steam page.

Get to know the game