Pinball Xperience
Eric Priepke

Eric Priepke

Current position
Software Developer | Pinball Programmer

Biography

ERIC PRIEPKE

Software developer and primary programmer behind Barrels of Fun’s interactive architecture

Eric Priepke holds a central role across the first four commercial machines produced by Barrels of Fun. Jim Henson’s Labyrinth, Dune, Winchester Mystery House and Bon Jovi change designers, rules teams, themes and sometimes creative structures, but his name remains consistently attached to software or coding. That continuity makes him one of the main contributors to the software identity Barrels of Fun has developed since entering commercial production.

His work sits at the intersection of disciplines that remain clearly separate. The game designer defines the physical architecture. Rules designers establish objectives, progression, scoring, modes and strategy. Artists, audio specialists and animators create the content. Priepke converts those elements into a system capable of tracking machine state in real time, controlling mechanisms, triggering the correct audiovisual sequences, resolving priorities when multiple events occur simultaneously and giving the player an immediate response.

That function carries particular weight at Barrels of Fun. The company’s machines use numerous motorized mechanisms, magnets, multiple displays, dynamic lighting, reactive audio and visual sequences that cannot operate as isolated components. Their effectiveness depends on how software coordinates them with the rules and with the physical movement of the ball. Priepke does not design the playfields of Labyrinth, Dune, Winchester Mystery House or Bon Jovi, but his code determines a substantial part of how those machines behave once a game begins.

Identity

Name

Eric Priepke

Profession

Software Developer | Pinball Programmer

Primary field

Pinball Software Development

Manufacturer

Barrels of Fun

First Barrels of Fun credit

Jim Henson’s Labyrinth

Role on Labyrinth

Software

Role on Dune

Software

Role on Winchester Mystery House

Software

Role on Bon Jovi

Coding

Associated platform

FAST Pinball

Major machines

Jim Henson’s Labyrinth | Dune | Winchester Mystery House | Bon Jovi

Rules collaborators

Phil Grimaldi | Bowen Kerins | Jess DeNardo

Game design collaborators

David Van Es | Travis Moseman | Karl DeAngelo

Audiovisual collaborators

Jeff Dodson | Joshua Clay | Trent Armstrong

Barrels of Fun | A structural role from the first machine

Jim Henson’s Labyrinth places Eric Priepke on software from the first commercial Barrels of Fun machine. David Van Es handles concept and game design, Travis Moseman works on engineering and mechanics, while Phil Grimaldi and Bowen Kerins contribute to the rules. Priepke has to make that collective architecture behave as a unified system.

The challenge extends far beyond scorekeeping or insert control. Labyrinth combines numerous physical mechanisms, magnets, diverters, targets, thematic sequences, animation, callouts and an extended visual environment on the back panel. Each element needs to respond to the correct game state while remaining coherent when several objectives progress at the same time.

This first machine already establishes the nature of Priepke’s role within Barrels of Fun. He is not credited as the primary rules designer or game designer. His responsibility is to convert those architectures into software behavior that can be executed reliably by a physical machine.

Jim Henson’s Labyrinth | Implementing an adventure-based ruleset

Labyrinth asks the player to progress through situations drawn from the film’s world. That structure works naturally for a narrative machine, but it creates a large number of intermediate states. The software has to know what has started, what has been completed, which objectives are available, which information needs to appear and which events can coexist.

The difficulty increases because the machine relies heavily on physical mechanisms. The code does not merely trigger animation. It must also control devices whose real behavior can alter the expected timing. A ball being held, released, redirected or moved by a mechanism will not always follow a perfectly fixed duration.

Priepke therefore has to manage the relationship between software state and physical events continuously. That constraint fundamentally separates pinball programming from the development of a completely digital game: the computer makes decisions, but the ball retains its own physical behavior.

Labyrinth | An ambitious launch and continued development

Labyrinth reaches the market with a highly ambitious software architecture for a first title. The scale of the rules, content and mechanical integration immediately gives the machine substantial depth, but the game also continues to evolve after release.

That post-launch development becomes a recurring characteristic of Barrels of Fun. Software is not treated as a completely finished block at the moment the first machines ship. Features, improvements and additional content can continue to be integrated after commercial release.

The benefit for longevity is clear. The limitation is equally important: a machine may reach its strongest software state after early customers have already received it. Priepke’s work therefore needs to be judged both by the maturity eventually achieved and by the condition of the game during different stages of its commercial life.

Software and rules design | Turning rules into behavior

Priepke’s work with Phil Grimaldi and Bowen Kerins on Labyrinth and Dune illustrates the distinction between rules design and programming particularly well. A rule can be perfectly clear on paper and become significantly more complicated once it has to coexist with everything else the machine is already doing.

A multiball can begin during a mode. A resource can be earned while another system is waiting for validation. A ball can enter a mechanism just as an audiovisual transition is supposed to begin. Two events can request control of the screen or audio system at the same time.

The software has to resolve these situations without exposing the complexity of those decisions to the player. When the system behaves correctly, the result feels natural: the appropriate event occurs, the machine responds and progression continues. The underlying programming becomes most visible when that coherence breaks down.

2025 | Dune | A significantly denser software architecture

Dune greatly expands the scope of the software. The game combines several parallel progression systems, resources, cycles, items, modes, multiballs and numerous intermediate states. Phil Grimaldi and Bowen Kerins develop the rules, David Van Es and Travis Moseman handle game design, and Priepke implements the resulting software architecture.

The density of the system directly changes the nature of the work. Dune is not built around a simple sequence of modes. Several layers can be prepared or exploited simultaneously, with interactions between resources, playfield states and scoring opportunities.

The code therefore has to track a large number of variables without losing consistency. That ability contributes heavily to the depth of the game, but it also creates its primary accessibility challenge: Dune can demand a great deal from the player before the relationships between its systems become immediately readable.

Dune | Cycles, resources and simultaneous states

The day/night cycle provides a useful example of this architecture. It is not simply a visual transition. The current cycle affects the way certain resources and opportunities are approached. Software has to preserve that state, communicate it and synchronize several machine responses with its progression.

Resources add another layer. Water, spice and items have to be tracked, displayed, consumed or retained according to the systems that use them. The player does not need to understand the internal variable structure, but every interaction has to remain consistent with the game’s actual state.

The quality of this architecture depends on continuity. A synchronization error, an incorrectly updated resource or an improper transition can undermine the player’s understanding of an entire strategy. On a machine this dense, software stability becomes directly connected with how clearly the rules are experienced.

Dune | Integration with Jeff Dodson’s sound design

The collaboration between Eric Priepke and Jeff Dodson demonstrates particularly well what programming adds to another creative discipline. Dodson can create an excellent sound effect, but the asset only acquires a gameplay function once it is associated with the correct event and triggered under the correct conditions.

Dune’s spinners provide a strong example. Their audio response needs to follow extremely rapid activations. Priepke and Dodson work around retrigger behavior so the repeated impulses remain perceptible without collapsing into an indistinct mass of sound. The final behavior depends both on the design of the audio asset and on how the code manages repetition.

The same principle applies to jackpots, resources and callouts. Some events need to move temporarily to the front of the mix, while others remain secondary. The software does not create the sound itself, but it determines when that sound is used and where the corresponding event sits within the hierarchy of the game.

Dune | Audio as an invisible interface

One of the most effective aspects of the Priepke / Dodson collaboration is the use of sound as an interface. Dune can confirm the collection of a resource or a change of state without forcing the player to look immediately at a display.

That method requires accurate programming. The sound response has to correspond exactly to the action registered by the game. A delayed, ambiguous or incorrectly triggered cue would undermine the player’s trust in that feedback.

Software therefore functions here as an interface without adding another visual element. The information exists because the code connects the physical event, the current rules state and the appropriate audio asset.

Dune | Animation and dynamic environment

The animation work of Joshua Clay and Trent Armstrong adds another layer to the architecture. The lower display can present Arrakis, Harvesters, Ornithopters or different environmental conditions connected with progression. These elements are not simply videos launched from a menu.

Their value depends on gameplay context. The code has to determine which animation is relevant, when it can appear, how long it can remain visible and what should interrupt it if a higher-priority event occurs.

Priority management is essential in modern pinball. A display may simultaneously need to communicate score, rules, a jackpot, a tutorial, a transition and a thematic event. Software has to arbitrate between those uses so that a visually elaborate sequence does not conceal information the player needs immediately.

Dune | Software richness and cognitive load

Dune is one of the densest projects in Priepke’s early Barrels of Fun portfolio. Its richness is a major strength: the machine offers several progression paths, substantial strategic construction and a large amount of long-term discovery.

That density also exposes the limitations of a sophisticated architecture. The software may understand the state of the machine perfectly while the player requires more time to understand the same information. When resources, cycles, modes and objectives coexist, the interface has to convert that internal complexity into usable feedback.

Priepke’s work cannot therefore be evaluated simply by counting how many systems are implemented. Success also depends on how clearly those systems communicate state changes and how consistently they interact. Dune reaches a high level of software depth while remaining more demanding to read than the more immediate titles in the Barrels of Fun catalog.

2025 | Winchester Mystery House | Changing designers without changing the software foundation

Winchester Mystery House becomes an important test of the Barrels of Fun production model. Karl DeAngelo replaces David Van Es as the primary game designer, while Priepke remains responsible for software. The manufacturer can therefore introduce a different physical architecture and creative sensibility without rebuilding its software culture around a new programmer.

That continuity has structural value. Tools, systems and development practices established through Labyrinth and Dune can support a third product even though the machine plays very differently. Software begins to function as studio infrastructure rather than as isolated code written for one game.

Winchester is built around a more atmospheric experience and an exploration of the mansion, with distinct areas, events and interactions. Priepke’s responsibility is to adapt the software architecture to that design rather than forcing the game to behave like Dune.

Winchester Mystery House | Programming a less system-heavy game

The difference from Dune is substantial. Winchester does not need the same quantity of overlapping resources or cycles to create depth. Much of its identity comes from atmosphere, progression through the mansion and the staging of individual events.

Software priorities therefore change. Greater systemic density would not automatically produce a better game. Programming has to support Karl DeAngelo’s intended pacing while giving the visual and audio sequences enough space to establish their atmosphere.

That adaptation demonstrates an important aspect of Priepke’s work: the code does not appear to impose a single structure across every Barrels of Fun game. Labyrinth, Dune and Winchester use software differently even though a common technical foundation connects them.

Winchester Mystery House | Collaboration with Jeff Dodson

Winchester also gives more space to Jeff Dodson’s audio work, with music, sound design and voice direction all contributing heavily to the machine’s identity. Priepke has to integrate that material into gameplay events.

Audio becomes especially important on a machine centered around a haunted location. Atmosphere, voices and effects can prepare an event before a mechanism moves. The code therefore needs to handle more than immediate switch-to-effect responses.

Some sequences require transitions, interruptions or different priorities depending on the current game state. Programming contributes directly to the continuity of the atmosphere, while the audio assets and their creative direction remain Dodson’s responsibility.

Winchester Mystery House | Greater readability with more fragmented pacing

Winchester benefits from a structure that is generally easier to follow than Dune. Fewer systems need to be monitored simultaneously and the machine places less pressure on the player to manage several overlapping economies.

Its limitations come more from the physical architecture and pacing. Some zones and sequences interrupt circulation, while several interactions function as separate destinations rather than components of one continuous flow.

Software cannot remove that characteristic without changing the game design itself. Its role is to exploit DeAngelo’s architecture correctly, synchronize the relevant states and maintain progression. Winchester therefore illustrates the limits of programming responsibility: software can strengthen or weaken a design, but it cannot replace its physical geometry.

2026 | Bon Jovi | Software as the conductor of an interactive concert

Bon Jovi changes the problem again. David Van Es returns to game design, Phil Grimaldi and Jess DeNardo develop the rules, and Eric Priepke handles coding. The fourth Barrels of Fun machine is built around seventeen songs and a progression system based on constructing a setlist and developing a concert performance.

Music introduces specific programming constraints. A song follows its own duration, but the game does not follow a fixed choreography. The player can miss a shot, accelerate progression, trigger a mechanism or begin an important sequence while the track continues.

Software therefore has to manage the relationship between the musical timeline and an unpredictable gameplay timeline. That coordination becomes more complex when lighting, animation, crowd effects, mechanisms and scoring all need to evolve in relation to the song.

Bon Jovi | Setlist and progression architecture

The rules developed by Phil Grimaldi and Jess DeNardo use song selection and the progressive construction of a setlist as a central structure. Priepke has to translate that concept into game states, preserve progression and manage transitions between the different phases.

This architecture requires careful internal persistence during a game. The software needs to know which songs have been played, which performances have been completed, which rewards have been earned and which possibilities remain available before the different Encore stages.

The complexity therefore differs from Dune. Bon Jovi relies less on interlocking resources and more on succession, performance states and the evolution of the concert itself.

Bon Jovi | Lightshows, animation and music

Joshua Clay and Trent Armstrong contribute animation and lightshow work associated with the different songs. That content cannot function effectively without close integration into Priepke’s code.

Each track can use a sequence of visual events, lighting changes and animations that need to remain connected with its progression while still allowing gameplay events to intervene. Some sequences are produced in After Effects, while others use dynamic elements integrated into the game engine.

The distinction matters. A pre-rendered video can operate as a relatively closed block. A dynamic animation can respond to game state, change under specific conditions or be interrupted when higher-priority information needs to appear. Software therefore manages different kinds of audiovisual content with different behavioral requirements.

Bon Jovi | Godot and dynamic animation

Development on Bon Jovi also pushes the collaboration with Trent Armstrong toward more dynamic integration. Armstrong begins working with part of the Godot pipeline so some animations can be layered or triggered according to game events rather than remaining completely fixed inside pre-rendered video.

Priepke retains responsibility for the machine’s coding. The graphical engine and assets created by the animation team therefore need to be connected with rules states, songs, scoring and physical events.

This architecture increases presentation flexibility. It also increases the number of interactions between software and content. As animations become more reactive, programming has to manage the conditions determining when they appear, how they change and when they are interrupted.

Bon Jovi | Crowd Engine and dynamic response

The Crowd Engine contributes to the simulation of a performance that evolves with the player. Jeff Dodson develops the sound component of that system, while software has to provide the gameplay states that allow crowd intensity and the broader machine response to change.

The audience therefore functions as more than background ambience placed beneath a song. It can participate in communicating progression and in shaping the sensation that the performance develops over the course of a game.

The quality of the result depends directly on coordination between rules, coding and audio. If the rules establish rising intensity while the sound remains static, the effect loses its purpose. If the audio changes without matching actual progression, the machine loses internal consistency. Software provides the link between those layers.

Bon Jovi | Current state of the code

Bon Jovi launches with an ambitious architecture built around seventeen songs, but not every track currently carries the same level of completion across all planned lightshows and animation layers.

That needs to be included in any evaluation of the current software package. The foundations are established, the setlist structure functions and the audiovisual integration already demonstrates the intended direction, but the presentation does not yet reach identical depth across the complete song library.

The situation reflects a characteristic already visible in previous Barrels of Fun releases: software continues to evolve after launch. That development model allows the machines to gain substantial content and refinement, but it also means the initial commercial version does not always represent the final functional or audiovisual maturity of the game.

Priorities, interruptions and event arbitration

A large part of Priepke’s work remains invisible when it functions correctly. A modern pinball machine can receive multiple events within fractions of a second. A target is hit, a resource is awarded, a mechanism activates, an animation begins and a jackpot becomes available.

Those events cannot all receive equal priority. Software has to decide what can stack, what needs to wait, what should interrupt another sequence and what can simply be recorded in the background.

That hierarchy directly affects the pacing of the experience. A game that constantly stops the player to present every event becomes heavy and intrusive. A game that allows everything to occur simultaneously risks making its information unreadable. Programming has to maintain a workable balance between those extremes.

Mechanisms | From software command to physical movement

Barrels of Fun machines use numerous physical systems whose states must be controlled through software. Magnets, diverters, motors, ball locks, targets, capture devices and license-specific mechanisms all require commands that correspond with the actual position and behavior of the ball.

That interaction introduces a difficulty absent from purely digital software. The program can send the correct command without guaranteeing that the ball will react exactly as expected. Code therefore has to incorporate sensors, state confirmation, timing and recovery behavior when a mechanism or ball does not follow the expected sequence.

Recovery behavior matters greatly to overall machine quality. A mechanism that works during a controlled demonstration is not enough. It also needs to return the game to a usable state when real gameplay produces an unusual situation.

Software and displays | Showing the correct information at the correct time

Barrels of Fun uses multiple display surfaces, including the primary display and the lower screen integrated into the back panel. The amount of available screen space could encourage permanent information overload, but the software challenge is to avoid presenting everything simultaneously.

The player primarily watches the ball. Critical information therefore needs to be prioritized according to when it becomes useful. Long-term progression can remain secondary, while an immediate decision, jackpot or selection requires more direct presentation.

Dune demonstrates the difficulty of that process because its ruleset contains many simultaneous systems. Winchester reduces that density. Bon Jovi adds the requirement of preserving the concert presentation. The three machines therefore need different display policies despite sharing a common technological foundation.

Updates | An architecture designed to evolve

The first four Barrels of Fun machines establish software updates as a normal part of the product cycle. Labyrinth continues receiving improvements well after release, Dune expands after commercial launch, Winchester develops further over time and Bon Jovi continues evolving across its song content.

This capability allows Priepke and the wider team to correct, balance and expand machines without altering their physical architecture. It effectively extends development well beyond the shipping date.

The model also requires discipline. An update must not solve one issue while creating a regression elsewhere. As a ruleset becomes larger, every new feature can affect existing states. Software maintenance therefore represents an increasing part of the workload as the Barrels of Fun catalog grows.

Four machines | An identifiable software continuity

Eric Priepke is associated with software across the first four commercial Barrels of Fun titles. That continuity allows the company to evolve its architecture without replacing its primary programmer for every new license.

Labyrinth establishes the foundation on an adventure machine rich in physical mechanisms. Dune significantly increases the density of rules, resources and audiovisual interactions. Winchester adapts that infrastructure to another game designer and a more atmospheric structure. Bon Jovi introduces synchronized music, lightshows, dynamic animation and concert progression.

The sequence demonstrates a role that extends beyond coding individual machines. Priepke’s work contributes to an internal Barrels of Fun software culture, with tools, methods and systems flexible enough to support substantially different designs.

Skills & Roles

Software Development | Pinball Coding | Gameplay Systems | Rules Implementation | State Management | Hardware Integration | Audio Integration | Display Logic | Interactive Systems | Software Maintenance

Machines and credits

Year

Machine

Manufacturer

Contribution

2023

Jim Henson’s Labyrinth

Barrels of Fun

Software

2025

Dune

Barrels of Fun

Software

2025

Winchester Mystery House

Barrels of Fun

Software

2026

Bon Jovi

Barrels of Fun

Coding

Key dates and contributions

Year

Milestone

Significance

2023

Jim Henson’s Labyrinth

First commercial Barrels of Fun software credit.

2025

Dune

Implementation of a denser rules architecture built around resources, cycles and parallel progression systems.

2025

Winchester Mystery House

Software development for a third title built around Karl DeAngelo’s game design.

2026

Bon Jovi

Coding for an architecture built around setlists, songs, concert progression and dynamic audiovisual integration.

Eric Priepke | Software Development at Barrels of Fun

Eric Priepke provides software continuity across the first four commercial Barrels of Fun machines. His work includes rules implementation, game-state management, mechanism control, event priorities and integration of audiovisual content created by other members of the team. That position places him directly between game design, rules development, engineering, animation and audio without conflating his credit with those disciplines.

Labyrinth establishes this architecture on the manufacturer’s first commercial machine. Dune greatly increases its complexity through parallel systems and advanced audio and visual feedback. Winchester demonstrates that the same infrastructure can support another game designer and a less system-heavy experience. Bon Jovi introduces additional constraints through seventeen songs, setlist progression, lightshows and dynamic content that must coexist with gameplay whose duration and event order remain variable.

Priepke’s primary identifiable contribution at Barrels of Fun is software integration. The company’s machines rely on a substantial number of mechanisms, rules systems and audiovisual elements that only become coherent once software connects them. Post-launch development remains an important characteristic of the catalog, meaning that the maturity of each program often continues to improve after initial deliveries. Across the four current titles, Priepke provides the technical continuity between changing game designers, rules designers and audiovisual teams while maintaining a software architecture capable of evolving from one machine to the next.

Highlights

  • Software Development
  • Pinball Coding
  • Gameplay Systems
  • Rules Implementation
  • State Management
  • Hardware Integration
  • Audio Integration
  • Display Logic
  • Interactive Systems
  • Software Maintenance

Key dates

  1. Jim Henson’s Labyrinth First commercial Barrels of Fun software credit.

  2. Dune Implementation of a denser rules architecture built around resources, cycles and parallel progression systems.

  3. Winchester Mystery House Software development for a third title built around Karl DeAngelo’s game design.

  4. Bon Jovi Coding for an architecture built around setlists, songs, concert progression and dynamic audiovisual integration.

Associated machines

6 machines