3D business simulation · Godot

A Cut Above: Mow & Grow

A lawn-care business simulation played from the mower seat, built in Godot 4.6 with GDScript.

Role
Solo project · AI-assisted since Aug 2026
Timeline
2022 – Present
Status
In development · Steam page live, playable build on itch.io
Platform
Windows
Stack
Godot 4.6 · GDScript · Godot shaders · MultiMesh · Jolt Physics · JSON persistence
An orange riding mower in tall grass, with freshly cut stripes ahead and a tree line beyond

How it was built

I started A Cut Above in 2022, and it’s the project I’ve worked on the longest. In August 2026 I started using AI coding agents (Codex and Claude Code), and since then they’ve written much of the new code. I plan the features and how the systems fit together, the agents implement them, and larger changes are written up in change reports. I check the results by playing the game and running the validation suites.

Highlights

  • Lawn tracking

    The mower deck marks cells on a grid that stores one byte per cell, and the grass shader reads it. This replaced 44,289 scene objects and 20,738 physics bodies on a medium lawn. A contract only finishes when the lawn is 100% mowed.

  • Generated properties

    A contract's seed decides its terrain, lawn, ponds, obstacles and forest. The generator is versioned, so properties saved with an older version keep the same layout.

  • Save system

    Saves are versioned JSON. Each one is written to a temporary file, read back and checked before it replaces the old save, and the old save is kept as a backup that loading can fall back to.

  • Testing

    27 validation suites with over 1,300 assertions run through the same systems the player uses, including the economy, jobs, weather and saving.

What it does

A Cut Above: Mow & Grow is a lawn-care business simulation played from the mower seat. You pick a contract from the job board in town, drive to the property, mow the lawn and get paid. The money goes into fuel, upgrades, new mowers and access to more service areas.

The full loop works: main menu, town, contract, mowing, payment and back to town.

The mowing system has to track exactly which parts of the lawn have been cut, save that progress partway through a job, and stay smooth while the game is also running weather, lighting and the rest of the property. That tracking feeds straight into the job system, since a contract isn’t finished until the lawn reaches 100%.

Riding mower partway through a lawn, with the contract checklist, clock, weather, fuel and grass catcher on screen
Mowing a contract, with the job checklist, clock, weather, fuel and grass catcher on screen.

What’s in it

  • The game flow from the menu to the town, to a job and back again, with one session controller that handles screen changes and the one path for finishing a job.
  • The money, contract and job completion systems that tie the loop together.
  • A property generator that builds the terrain, lawn, ponds, obstacles, forest and distant scenery for each job from its seed.
  • Three mower types (riding, powered walk-behind and push), each with its own handling, plus fuel, refuelling and upgrades.
  • A job market with expiring offers, service territories, recurring service agreements, rival firms and a day-by-day economy.
  • A world clock for weather and time of day that carries across every scene change and is saved with the game.
  • Saving and loading for the business, the world and partly mowed lawns, through one save service that collects the state from each system.
  • Validation scenes, and an in-game developer debugger that only changes state through the systems that own it.
Job board listing two residential contracts with estimated time, pay, site and expiry
Job offers come in and expire as time passes in the game.

Problems and fixes

  • The original lawn gave every patch of grass its own physics object so the mower could tell when it drove over it. A medium lawn ended up with 44,289 scene objects and 20,738 physics bodies. That was replaced with a grid that stores one byte for each square unit of lawn, and the grass shader reads it to draw each area as cut or uncut. The same lawn now uses one scene object and no physics bodies, and the progress counters update in constant time.

  • Bigger properties shouldn’t cost more to draw. The amount of grass drawn each frame depends on how far the player can see, not on the size of the whole property. In stress tests, draw calls stayed between 126 and 178 for lawns from 256 to 2,000 world units across. The grass is drawn in batches using Godot’s MultiMesh system, and the before and after measurements are written up in the repository.

  • Instead of saving the whole generated scene, a contract stores its seed and a few generated values, and the terrain, ponds, forest and obstacles are rebuilt from the seed. The property generator is versioned and keeps code paths for older versions, so a property saved with an older generator keeps its layout.

  • Saves are versioned JSON. Each save is written to a temporary file, read back and parsed, and only then replaces the old one, which is kept as a backup that loading falls back to. A compatibility test loads save files from older versions to make sure updates don’t break them.

  • The tests run the actual game instead of a simplified copy of it. There are 27 validation suites with more than 1,300 assertions covering the business, economy, jobs, weather, saving and more. The test scenes use the same systems the player does: they drive mowers, refuel and finish jobs through the real game logic.

Technologies

  • Godot 4.6
  • GDScript
  • Godot shading language
  • Jolt Physics
  • MultiMesh instancing
  • GPU particles
  • Sky3D (through a custom adapter add-on)
  • JSON persistence
  • AI coding agents (Codex, Claude Code)

There's a Windows build on itch.io, and the game can be wishlisted on Steam. The GitHub repository has the code, the architecture and performance documents, and the validation suites. Some art assets aren't included in it.