I joined late in development to help bring a John Deere combine harvesting simulator across the finish line for a live CES 2026 showcase. My focus was on making the harvesting experience feel convincing and readable while keeping performance stable for a demo environment. I worked as a generalist in Unreal Engine 5, spanning visuals, systems polish, audio feedback, and optimization.

Role: Unreal Engine Developer

Project Length: Dec 2025 to Jan 2026

Tools: Unreal Engine 5, Blueprint

Context: Live CES demo showcasing new Combine Harvester features

Client: John Deere

Employer: Tipped Chair (contract)

What I owned

  • Harvesting visuals: RVT-driven shader workflow to cut/bend corn at scale

  • PCG corn fields: placement rules, material optimization, and performance tuning for a live demo

  • Grain-to-cart visuals: arranged/implemented mesh setup for grain dropping into the cart mechanic

  • Guidance UI shader: arrow color feedback based on distance from the ideal path/spline (green → yellow → red)

  • Audio: gear-switching playback states + mixing for clearer player feedback

What I wanted to achieve

The client needed a demo that would hold up under CES conditions: consistent, readable, and visually convincing, even after repeated play sessions.

Key goals

  • Performance you can trust: stable runtime performance for a live show floor demo

  • Clear harvesting feedback: corn should visibly react when cut, and the player should feel the machine state changes

  • Believable density at scale: lots of corn stalks without the level collapsing under cost

  • Polish and usability: smooth, understandable experience for first-time users

  • Showcase AI Alignment Adjustments: the game takes control halfway through to show the new combine’s features to align and adjust position and speed to the grain cart

How I wanted to achieve it

My approach was to reduce risk quickly: make performance predictable first, then spend the remaining time on “feel” and clarity.

Plan

  • Use PCG to control density, variation, and placement efficiently, with knobs for performance

  • Use RVT-driven shaders to sell harvesting interaction across large areas without heavy per-asset logic

  • Add particles and audio state changes to make cutting and gear switching instantly readable

  • Iterate directly with stakeholders using short feedback loops and targeted fixes

Process

1) Audit and identify the highest costs

I started by profiling the scene and focusing on what mattered most for a live demo: vegetation cost, material complexity, and readability in motion. From there, I built a short hit list of changes with the best effort-to-impact ratio.

2) Build harvesting visuals that scale

I implemented harvesting visuals using RVT-driven shaders so corn could bend and cut convincingly across large areas. This lets the interaction read clearly while staying performant for hundreds of stalks on screen.

3) Make corn placement controllable and efficient with PCG

I developed the corn field using PCG, then iterated on material setup, instance density, and placement rules to balance looks and performance. PCG gave us fast iteration when stakeholders wanted adjustments without requiring manual rework.

4) Improve feedback with audio and VFX

I implemented gear-switching audio with state-driven playback and mixing so the player could instantly understand changes in machine behavior. I also added particle effects for cutting feedback when the combine passes through stalks.

5) Grain-to-cart feedback

I helped implement and arrange the mesh setup for the grain dropping into the cart. The goal was to make “successful harvesting” visible at a glance, so spectators and first-time players could instantly understand what progress looked like during the demo.

6) Guidance arrow UI

To improve clarity for new players, I built a shader-driven arrow UI that changes color based on how closely the player follows the ideal spline path: green when centered, yellow when drifting, and red when significantly off-course. This gave players immediate correction feedback without adding extra text or tutorial prompts.

What I learned

  • Demo-ready is a different bar: stability and clarity matter as much as visuals, especially when users are seeing it for the first time.

  • PCG is a production tool when treated like one: strong parameterization and constraints made it easy to iterate without breaking performance.

  • RVT can do heavy lifting: it is a powerful way to sell interaction across big environments without expensive per-object logic.

  • Stakeholder iteration is a design skill: fast, concrete check-ins helped me prioritize changes that improved the experience the most.