The Return of Rapid Reporter

So, I did a thing. I re-wrote Rapid Reporter from scratch.

Here’s why.

You can find the project here:github.com/deefex/rapid-reporter

1. History

I need to start by paying homage to the OG Rapid Reporter tool and its creator, Shmuel Gershon. It’s his baby, and the original download links are still here.

When Rapid Reporter first came to my attention, I wasn’t using Windows platforms in my day-to-day work. That was frustrating — because the tool immediately resonated with me. It was lightweight, fast, and clearly built with exploratory testing in mind. But it wasn’t something I could actually use.

That frustration led to an early attempt to create a Mac-friendly version (that link is now long gone), followed by a second iteration where I tried to bring the look and feel closer to the original.

Native Mac development, however, comes with its own learning curve. Xcode and Swift were both new territory for me at the time — and just as I was getting comfortable, Apple would change the ground beneath my feet. Each year seemed to bring significant updates, not just to Xcode, but to Swift itself.

Maintaining the tool began to feel less like ownership and more like an annual tax.

Eventually, it fell by the wayside.

2. Why bring it back?

Despite loving the premise of Rapid Reporter, there were always aspects of it that didn’t quite work for me, and I should stress — these were entirely subjective, and often a product of the technology available at the time.

The grid-like, CSV-style output never really sat comfortably with me. Everything being timestamped created something that felt more like machine output than a human narrative. Plain text meant limited formatting options, and over time, I found it harder to visually parse what I had actually just written.

There were ways to step back and review previous entries, but they required additional key presses — a small thing, perhaps — yet enough to introduce friction into what should be a fluid exploratory workflow.

Over the intervening years, I developed my own approach to exploratory testing note-taking. Markdown became my default medium, paired with the selective use of icons to support debriefs and stakeholder conversations.

That shift changed everything.

Instead of producing a log, I was producing a story.

Icons helped draw the reader’s attention to the important moments — bugs, ideas, observations — especially when someone was skim-reading. The emphasis moved away from timestamps and towards context, reasoning, and narrative.

Meanwhile, the original Mac port I had built was long gone. The source code had vanished somewhere along the way, and a brief flirtation with modern Xcode and Swift quickly reminded me how much effort it would take to resurrect it.

It raised a bigger question:

If I were going to rebuild this… why should it be tied to a single desktop platform at all?

By this point, I’d been exposed to a much broader range of technologies. Surely cross-platform tooling now existed that could make this both familiar to build and sustainable to maintain?

3. The Rewrite Decision

So this wasn’t just about rebuilding what I had lost; it was about deciding whether it was worth rebuilding that version at all. The previous attempts had been shaped by the constraints of the native macOS development. That brought a certain elegance with it, but at a hidden cost.

Maintenance wasn’t just about improving the tool; it meant keeping pace with Apple’s ecosystem. Each year brought changes – new Swift versions, new Xcode behaviours, new platform expectations.

Keeping the tool alive began to feel less like evolving a product and more like renewing a licence to exist, and crucially, it remained tied to a single operating system.

So the decision stopped being ‘How do I rebuild Rapid Reporter?’ and became ‘What would Rapid Reporter look like if I built it today, with the benefit of everything I’ve learned since?’

The question made the answer obvious. If this was going to return, it couldn’t just be a revival; it needed to be a rethink.

Not a port. Not an update. A rewrite.

4. Choosing the Technology

I focused on the frontend first, as I wanted something that would allow me to retain the aesthetic of the original (single line input, subtle timer progression, labels for category changes, etc.) as those elements still resonate today. The premise of this tool being a wee unobtrusive window on your desktop, ever present, always on top, but not overbearing in any way, shape or form was definitely something I wanted to keep. I also wanted to create and maintain a workflow in the frontend for things that had already been captured. React seemed like a natural fit for this, as I had a decent amount of exposure to it from previous roles.

Rust seemed like a good choice for the backend for the following reasons:

• It’s predictably fast. Native performance with low overhead
• Memory safety without a garbage collector. You get a big chunk of C/C++ powers, but with far fewer ways to shoot yourself in the foot
• Great for OS work that the frontend shouldn’t have to do
• Shipping is cleaner. Compiles into a single native binary, smaller installers, fewer runtime dependencies, and fewer ‘works on my machine’ surprises
• Concurrency when you need it. Offload image processing, export work in the background, safe concurrency primitives and a strong ecosystem.
• Ecosystem is practical for your needs. chrono for timestamps, serde for clean JSON payloads between React/Rust, image for cropping.

That left one obvious question:

How do you actually turn a React UI and a Rust backend into a native desktop app?

This is where Tauri came in.

At its core, Rapid Reporter isn’t a web app. It’s a desktop companion. It needs:

• to sit quietly above other apps
• interact with the file system
• capture screenshots
• feel native rather than browser-like
• ship as a proper installer

Tauri provides a clean bridge between a modern web UI and a native system layer without dragging in the weight of a full browser runtime.

Instead of bundling Chromium (as Electron does), Tauri uses the operating system’s native WebView. That means – smaller installs, lower memory usage, faster startup, fewer moving parts.

Architecturally, it also maps nicely to how Rapid Reporter behaves:

Layer	Responsibility
React	Interaction, workflow, visual presence
Rust	OS integration, exports, image handling
Tauri	Secure a bridge between the two

Tauri essentially becomes the runtime that allows Rapid Reporter to look modern, behave natively & remain lightweight without forcing the project down the path of a heavyweight desktop stack.

In short, it let me build something that feels like a native tool — not a web page in disguise.

5. The Modern Capabilities

The original Rapid Reporter was ahead of its time in many ways — fast, lightweight, and built around the needs of exploratory testers. But technology (and expectations) have moved on.

This modern re-implementation keeps the spirit of the original intact while introducing capabilities that better support how exploratory testing is practised today.

5.1 Session-Centric by Design

At its core, Rapid Reporter remains anchored in Session-Based Test Management.

You begin with intent:

• Tester
• Charter
• Duration

Once a session starts, the tool becomes a quiet companion — always-on-top, present but unobtrusive — tracking time while you focus on exploration.

There’s no dashboard to manage. No workspace to organise.

Just a single instrument panel that supports the work as it unfolds.

5.2 Fast, Structured Note Capture

Notes can be captured instantly using a keyboard-first workflow and categorised as:

• Test
• Bug
• Warning
• Observation
• Question
• Idea
• Snippet

Each entry becomes part of the session narrative — not just a timestamped record, but a structured story of what happened and why it mattered.

Snippet support allows structured data or technical findings to be captured cleanly and exported as properly formatted Markdown code blocks.

5.3 Screenshots as First-Class Evidence

Modern exploratory testing often relies on visual context.

Rapid Reporter treats screenshots as a native note type — not an attachment.

You can capture full-screen & region-based captures

Each screenshot is stored, timestamped, and embedded directly into the final session report.

Rather than interrupting the flow to organise evidence later, the evidence is captured in context.

5.4 Recap Without Breaking Flow

One of the limitations of earlier tools was the difficulty of recalling what had just been recorded.

Rapid Reporter introduces a recap panel showing the most recent entries — helping maintain awareness without requiring navigation or review actions.

This preserves cognitive flow while preventing context loss during longer sessions.

5.5 Markdown Export for Narrative Reporting

When a session ends, Rapid Reporter produces a structured Markdown report including:

• Session metadata
• A visual summary of key findings
• Chronological notes
• Embedded screenshots
• Technical snippets

The output is portable, readable, and suitable for:

• Debriefs
• Stakeholder sharing
• Documentation
• Test evidence archives

Rather than producing raw logs, the goal is to produce something that tells the story of the session.

5.6 Cross-Platform from the Ground Up

Unlike earlier iterations, this version was designed to run across:

• macOS
• Windows
• (and potentially Linux)

This ensures that exploratory testers can adopt the same workflow regardless of platform — without being constrained by native tooling limitations.

5.7 A Tool That Stays Out of the Way

Above all, Rapid Reporter is designed to minimise friction.

It doesn’t attempt to replace test management systems.

It doesn’t try to formalise exploration.

It simply supports the tester in capturing intent, observations, and evidence — quickly, consistently, and with minimal interruption.

6. The Cross-Platform Reality Check

One of the core goals of the rewrite was clear from the outset:

Rapid Reporter should work across platforms.

Not just compile across platforms — but feel at home on them.

And for the most part, that goal has held up well.

• The instrument panel behaves consistently.
• Session capture works the same way.
• Exports are identical.

But there is one area where the illusion of uniformity breaks down:

Region capture.

On macOS, the experience is smooth.

• The application can present a lightweight, transparent overlay across the desktop.
• The user drags to select an area.
• The selection is captured.
• Flow remains uninterrupted.
• It feels native — because it aligns with how macOS expects desktop tools to behave.

Windows, however, tells a different story.

Despite using the same architecture, the same UI concepts, and the same underlying intent, the behaviour diverges in subtle but important ways.

• Transparent overlay windows are harder to manage reliably.
• Always-on-top behaviour can conflict with system-level window handling.
• Input focus becomes unpredictable.
• And the WebView2 runtime — the foundation for rendering the application UI on Windows — introduces constraints that simply don’t exist on macOS.

What works elegantly on one platform can become fragile on another.

The result is inconsistency.

Region capture does not behave the same way across platforms.

And that’s not due to lack of effort or parity in implementation — but because the operating systems themselves expose different capabilities and limitations when it comes to:

• window transparency
• input capture
• overlay rendering
• desktop composition

This became an important lesson in the rewrite.

Cross-platform does not mean identical capability, and native behaviour is not abstracted away simply by using modern tooling.

Each operating system still has its own rules.

7. Where It Stands Today

After the rewrite, the iteration, and a few real-world lessons about what cross-platform truly means, Rapid Reporter is back — and in active use.

Today:

• macOS: Fully working
• Windows: Fully working
• Version: v1.0.4 shipped

The core experience — fast, low-friction capture of exploratory testing notes — is stable across platforms.

• Sessions can be started quickly.
• Notes flow without interruption.
• Screenshots and snippets become part of the narrative.
• Exports are clean, readable, and immediately usable in debriefs.

Most importantly, Rapid Reporter once again fulfils its original promise:

A lightweight, always-present companion that supports thinking, not process.