A Go Framework Packs Experiments Into One Self-Contained Binary

If you've ever tried to run the same psychology task on different lab computers, the software can be the real obstacle. Goxpyriment tackles that problem by compiling a whole behavioral or cognitive experiment into a single executable file, with zero runtime dependencies. Because Go can embed graphics, audio files, and stimulus lists directly into the program, collaborators and testing machines do not need a separate runtime setup. The framework is inspired by Expyriment and includes text, shapes, images, Gabor patches, motion clouds, WAV playback, and tone generation. It also takes timing seriously: the operating system timestamps input events at hardware-interrupt time, so reaction times come from comparing two OS-level timestamps instead of continuous polling. Go's garbage collector can be disabled to reduce unpredictable pauses that could disrupt stimulus timing. The authors also provide more than forty psychology experiments built with Goxpyriment, and they say these examples help both humans learning the system and AI-assisted coding tools.

A lab task can now fit in one file. That is the surprise at the heart of Goxpyriment. If you have ever watched a study break because one computer lacks the right setup, the pain will feel familiar. The framework turns a full behavioral or cognitive experiment into a single executable binary. It also carries its own assets inside that file. That means graphics, audio, and stimulus lists travel with the program. The result is simple to share with collaborators and easier to test on lab machines. The paper mentions more than forty built-in experiments, so the idea is not just tidy in theory. It already comes with a lot of practice.

Why one file matters in a lab

This is not just a packaging trick. Experiment software sits at the center of behavioral and cognitive research. Small setup problems can change how smoothly a study runs. They can also hurt reproducibility, which means two labs may not get the same result from the same task. Goxpyriment aims at that weak point. It answers a very plain need. A collaborator should be able to take an experiment, run it, and trust that the same pieces are there on the other side. The framework uses the Go language, which is compiled. That lets it bundle the whole experiment into one self-contained program with zero runtime dependencies. In lab life, that kind of portability can save both time and frustration.

How Goxpyriment keeps the timing honest

Timing is the other half of the story. A psychology task is only useful if the system records responses at the right instant. Goxpyriment tackles that with operating-system timestamps, which are time marks made by the computer itself. The program does not depend on constant polling, which means it does not keep asking the device again and again for a response. Instead, it subtracts one OS-level timestamp from another to get reaction time. The framework also lets users turn off Go's garbage collector, the memory-cleanup system that can sometimes pause a program. Those pauses are rare, but they can still blur the timing of a stimulus. The aim here is simple. Keep the machine quiet when timing matters most.

What the built-in examples do for people and tools

The built-in experiments do more than show what the framework can do. They give users working examples to study and adapt. The paper says they help people learn the system. It also says they improve how modern AI-assisted coding tools help program experiments. That is a useful twist. Good examples do not just teach syntax. They also show structure, style, and the rhythm of a real task. Goxpyriment includes visual stimuli such as text, shapes, images, Gabor patches, and motion clouds. It also supports audio through WAV playback and tone generation. Those pieces matter because experiment design often mixes what people see and hear. The library tries to make that work feel human-friendly, not cryptic.

Where the idea could go next

The most interesting consequence is practical, not flashy. A lab no longer has to choose between rich experiment features and easy sharing. Goxpyriment says you can have both in one package. That makes it easier to send a task to a collaborator, test it on another machine, and keep the same stimulus set intact. The framework is also open source under GNU General Public License v3, so it can be inspected and reused. The paper stays focused on software, not on a new cognitive result. Still, the design choice is clear. It shifts the hardest part of experiment work away from setup chores and toward the task itself. That is a real gain for any group that needs clean timing and fewer moving parts.