Turn Your Phone Into a Secret Radio Transmitter: Time Station Emulator Exposed

Turn Your Phone Into a Secret Radio Transmitter: Time Station Emulator Exposed

What if I told you the smartphone in your pocket is hiding a superpower that almost no one knows about? Not the camera. Not the GPS. Something far more bizarre—and arguably more useful in the right situation.

Here's the painful truth: you've probably got a "radio-controlled" clock or watch sitting dead on your shelf right now, its self-setting feature permanently broken because you live too far from Fort Collins, Colorado, or Frankfurt, Germany, or wherever your nearest atomic clock transmitter happens to be. Urban interference kills these signals dead. Mountains block them. Buildings absorb them. Millions of supposedly "smart" timepieces become expensive paperweights because they can't hear the invisible radio whisper that keeps them accurate.

But what if your phone could become that transmitter?

Enter Time Station Emulator—a mind-bending piece of engineering that transforms virtually any modern phone or tablet into a low-frequency radio station broadcasting legitimate time synchronization signals. No additional hardware. No soldering irons. No FCC license. Just pure software wizardry exploiting the physics of digital audio conversion.

This isn't science fiction. This is a real, working project that's already helping people sync their atomic clocks in places where real broadcasts simply don't reach. And the technical ingenuity behind it will make you look at your phone's speaker completely differently.

What Is Time Station Emulator?

Time Station Emulator is an open-source browser application created by kangtastic that emulates five major global radio time signal stations: China's BPC, Germany's DCF77, Japan's JJY, the UK's MSF, and the USA's WWVB. These are the actual stations that real "atomic" clocks listen to for automatic time synchronization.

The project lives at https://github.com/kangtastic/timestation and is hosted for immediate use at https://timestation.pages.dev/.

What makes this project genuinely remarkable isn't just what it does—it's how it does it. Rather than requiring specialized radio transmission hardware, Time Station Emulator exploits a fascinating quirk of digital-to-analog conversion. It generates precisely crafted audio waveforms that, when played through your device's speaker, create harmonic RF leakage that mimics genuine time station broadcasts. Your phone's built-in speaker and the circuit traces connecting to it become an ad-hoc antenna.

The project is built with a surprisingly sophisticated tech stack for something that appears so simple on the surface: C for core signal generation, TypeScript and Lit for the web interface, and WebAssembly to bridge the performance-critical signal processing into the browser. This architecture enables real-time, client-side waveform generation without any server dependencies or data collection.

Time Station Emulator is trending now because it solves a genuinely unsolved problem with zero hardware cost. In an era of increasingly locked-down consumer electronics, finding a clever software-only hack that unlocks hidden hardware capability feels like discovering a secret passage in your own house.

Key Features That Make This Insanely Useful

Five-Station Compatibility: The emulator doesn't just support one standard—it covers all five operational radio time signal stations globally. This matters because different clocks support different stations. A clock purchased in Japan expects JJY. One from Germany wants DCF77. American clocks listen for WWVB. Time Station Emulator speaks all these languages fluently.

Network Time Precision: Rather than relying on your device's potentially inaccurate system clock, the application derives time using an NTP-like algorithm over the network. This ensures the signal you're broadcasting is actually correct, not just whatever your phone happens to think the time is.

Location-Agnostic with ±24 Hour Offset: Traveling? Clock confused about time zones? The emulator supports applying time offsets of up to 24 hours in either direction. This is crucial for testing, for setting clocks to different time zones, or for situations where you need to deliberately mislead a clock (debugging, calibration, or just showing off).

Daylight Saving Time Intelligence: The system automatically transmits correct DST information for DCF77, MSF, and WWVB. This isn't trivial—DST rules are notoriously complex and vary by jurisdiction. Getting this wrong means clocks spring forward or fall back at the wrong moments.

Leap Second Awareness: For MSF and WWVB, the emulator transmits DUT1 offset information. Leap seconds are the arcane but real adjustments made to atomic time to keep it synchronized with Earth's rotation. Most software ignores them. Time Station Emulator doesn't.

True Zero-Install Operation: Runs entirely in the browser via WebAssembly. No app store. No installation. No account creation. No data collection. This is privacy-respecting software in an era where that's increasingly rare.

Real-World Use Cases Where This Shines

Urban Apartment Dwellers with Dead Clocks: Live in a concrete high-rise in Manhattan, Tokyo, or London? Real time signals often can't penetrate. Your "atomic" clock becomes a manual-set relic. Time Station Emulator brings it back to life by generating the signal locally, from inches away instead of hundreds of miles.

Travelers with Multi-Region Clocks: Bought a beautiful radio-controlled watch in Germany but now live in Australia? Instead of hoping for impossible signal propagation, place your phone next to the watch and transmit DCF77 directly. The clock never knows it's not in Frankfurt.

Clock Repair and Resale Professionals: Testing radio-controlled clocks requires knowing they can actually receive and decode signals. Professionals can verify functionality without waiting for optimal signal conditions or middle-of-the-night automatic sync attempts.

Preppers and Off-Grid Enthusiasts: When real infrastructure fails—geomagnetic storms, transmitter maintenance, whatever—having a backup time synchronization method that runs on any phone is genuinely valuable for maintaining accurate timekeeping.

Developers Building Time-Critical Applications: Need to test how your application behaves with specific time signals, DST transitions, or leap second handling? This provides controlled, repeatable signal generation without specialized RF equipment.

Step-by-Step Installation & Setup Guide

Here's where Time Station Emulator gets almost embarrassingly simple compared to what it accomplishes.

Prerequisites

The hard requirements are minimal:

• Browser with WebAssembly support (virtually anything from 2019+)
• DAC supporting ≥44.1 KHz PCM (standard on all modern devices)
• Built-in speaker strongly preferred (explained in technical details below)

Access the Application

No installation required. Simply navigate to:

https://timestation.pages.dev/

The entire application loads and runs client-side.

Configuration Steps

Step 1: Select Your Target Station

Open the web interface and choose which time station to emulate. The critical choice depends on your clock:

• BPC (China, 68.5 kHz): For clocks from mainland China
• DCF77 (Germany, 77.5 kHz): European clocks, most widely supported globally
• JJY (Japan, 40/60 kHz): Japanese domestic clocks
• MSF (UK, 60 kHz): British and some European clocks
• WWVB (USA, 60 kHz): North American clocks

Certain configuration options only appear for compatible stations.

Step 2: Configure Time Offset (If Needed)

Apply ±24 hour offset if your clock needs different timezone handling, or if you're testing specific time scenarios.

Step 3: Prepare Your Clock

Navigate your clock's menus to force synchronization mode. This varies by device—consult your manual. Typically involves holding specific buttons or navigating to "RC" or "radio control" settings.

Step 4: Critical Positioning

Place your phone's speaker as close as physically possible to your clock's internal antenna. The transmission range is intentionally very short—often just centimeters. Experiment with orientation; the antenna location varies by clock model.

Step 5: Volume Configuration

Set volume to maximum or near-maximum. The generated waveform uses full dynamic range but is pitched beyond normal human hearing.

⚠️ CRITICAL SAFETY WARNING: DO NOT place your ears near the speaker to check volume. Use visual indicators only. Even when you "can't hear anything," the output can cause permanent hearing damage at sufficient levels.

Step 6: Transmit and Hold

Start transmission and maintain position. Successful synchronization typically completes within three minutes.

Browser Compatibility Notes

As of early 2024, Safari on iOS and Firefox on Android had significant breaking issues. By early 2026, these appear resolved for many users. Chrome and Chromium-based browsers generally work reliably.

REAL Code Examples: How the Magic Actually Works

While Time Station Emulator runs entirely in your browser without requiring you to touch code, understanding the implementation reveals genuine engineering elegance.

Core Signal Generation Architecture

The project uses C for performance-critical waveform generation, compiled to WebAssembly for browser execution. Here's the conceptual approach from the implementation:

// Core principle: Generate subharmonic that creates target frequency as harmonic
// For WWVB at 60kHz with 48kHz sample rate:
// Nyquist frequency = 24kHz
// Highest odd subharmonic below 24kHz = 60kHz / 5 = 12kHz
// 5th harmonic of 12kHz = 60kHz (our target!)

// The C implementation generates this modulated subharmonic,
// which the DAC's inherent nonlinearity reconstructs into
// the original carrier frequency through harmonic generation

This isn't merely playing a recording—it's mathematically constructing a waveform whose unintended consequences (DAC harmonic distortion, normally the enemy of audio quality) become the desired output.

WebAssembly Bridge in TypeScript

The browser interface loads and instantiates the WebAssembly module:

// From the project's TypeScript/Lit architecture
// The WebAssembly module is loaded and exposes C functions to JavaScript↗ Bright Coding Blog

class TimestationAudio extends AudioWorkletProcessor {
  // AudioWorklet provides real-time, low-latency audio processing
  // This is crucial for maintaining precise timing in the generated signal
  
  process(inputs, outputs, parameters) {
    const output = outputs[0];
    // Call into WASM for sample generation
    // The C code handles the complex modulation math
    // JavaScript just orchestrates the audio pipeline
    this.wasmInstance.exports.generate_samples(
      this.sampleBufferPtr,
      output[0].length
    );
    // Copy generated samples to output channels
    // ...implementation details...
    return true; // Keep processor alive
  }
}

The AudioWorkletProcessor is specifically chosen over older Web Audio API approaches because it runs on a separate thread with minimal latency jitter—critical when your signal's meaning depends on precise microsecond-level timing variations.

Time Encoding Implementation

Each station uses distinct encoding. For WWVB, the time code includes:

// WWVB time code frame structure (simplified conceptual view)
// Each minute contains 60 seconds of data
// Marker bits (P0, P1, P2) at positions 0, 9, 19, 29, 39, 49, 59
// Data bits use pulse-width modulation: 0.2s = 0, 0.5s = 1, 0.8s = marker

struct wwvb_frame {
  uint8_t minute_bits[8];      // Minutes 00-59
  uint8_t hour_bits[6];        // Hours 00-23
  uint8_t day_bits[10];        // Day of year 001-366
  uint8_t year_bits[8];        // Year within century 00-99
  uint8_t leap_year_bit;       // Leap year indicator
  uint8_t leap_second_pending; // Warning: 61st second coming
  uint8_t dst_status[2];       // US DST in effect / pending
  // ...additional fields for DUT1, etc.
};

The actual C implementation generates the precise amplitude-reduced carrier (17 dB below full power for "0" bits, full power for "1" bits, with markers at different timing) in real-time, using the current network-derived time to populate all fields correctly.

Web Interface with Lit

The user-facing configuration uses modern web components:

// Simplified conceptual view of the Lit-based UI
import { LitElement, html, css } from 'lit';

@customElement('timestation-config')
export class TimestationConfig extends LitElement {
  // Reactive state management for station selection
  @state() private _selectedStation: StationCode = 'WWVB';
  @state() private _timeOffset: number = 0;
  @state() private _dstEnabled: boolean = true;

  render() {
    return html`
      <div class="config-panel">
        <station-selector
          .value=${this._selectedStation}
          @change=${this._onStationChange}>
        </station-selector>
        
        ${this._selectedStation === 'DCF77' || 
          this._selectedStation === 'MSF' || 
          this._selectedStation === 'WWVB' 
          ? html`<dst-toggle
                   .checked=${this._dstEnabled}
                   @toggle=${this._onDstToggle}>
                 </dst-toggle>`
          : nothing}
        
        <time-offset-slider
          .value=${this._timeOffset}
          min="-24" max="24"
          @input=${this._onOffsetChange}>
        </time-offset-slider>
      </div>
    `;
  }
  
  // ...event handlers and validation...
}

The conditional rendering of DST controls based on station selection demonstrates the thoughtful UX—only showing relevant options rather than overwhelming users with inapplicable settings.

Advanced Usage & Best Practices

Optimize Transmission Success: The built-in speaker of phones and tablets works best because the entire device chassis can act as a coupled antenna. Wired earbuds can work in some cases due to the long cable runs. Bluetooth and high-end audio equipment intentionally suppress the high-frequency harmonics this technique relies upon—avoid them.

Antenna Hunting: If your clock won't sync, the antenna location is likely suboptimal. Try rotating the clock relative to your phone. The ferrite loop antennas in most radio-controlled clocks are directional. Perpendicular orientation often works better than parallel.

Environmental Control: Metal surfaces, other active electronics, and even your body can affect the weak near-field transmission. Minimize interference by clearing the immediate area.

Timing Strategy: Real stations are weakest during daylight due to ionospheric changes. If you've struggled with real reception, your clock may be programmed to sync primarily at night. You may need to manually force sync during daytime testing.

Debugging with Offset: Use the ±24 hour offset to verify your clock is actually receiving your signal, not accidentally catching a distant real broadcast. Set a distinctive offset and confirm the clock shows that wrong time—then you'll know your setup works.

Comparison with Alternatives

Time Station Emulator uniquely occupies the intersection of zero cost, zero complexity, universal portability, and reasonable effectiveness. It won't replace a professional RF lab setup, but for actual real-world clock synchronization, it's often more practical than alternatives costing hundreds of dollars.

The privacy angle is underrated—no GPS tracking, no account, no cloud service knowing when you set your clocks. In an increasingly surveilled world, even small victories matter.

Frequently Asked Questions

Is this actually legal?

The emissions are extremely weak by design—intentionally leveraging incidental RF leakage rather than deliberate transmission. The effective range is centimeters, not kilometers. This falls well within regulatory frameworks for unintentional radiators. You're not broadcasting a radio station; you're playing audio that happens to have harmonic consequences.

Will this damage my phone's speaker?

The generated waveforms are within normal audio frequency ranges (the subharmonics, not the RF harmonics). No special speaker stress occurs. The warning about hearing damage applies to your ears, not the hardware.

Why doesn't my Bluetooth speaker work?

Bluetooth audio codecs aggressively filter "inaudible" frequencies and introduce compression artifacts. The precisely crafted harmonic relationships that make this technique work are destroyed by this processing. Use wired connections or built-in speakers only.

Can I use this to set my neighbor's clocks?

Extremely unlikely. Effective range is typically under 10 centimeters. The signal strength drops off with the sixth power of distance in near-field conditions. Your neighbor is safe from your time-telling pranks.

Does it work with all radio-controlled clocks?

Most, but not all. Some very old or very cheap clocks may have inadequate sensitivity. Clocks supporting multiple stations may prefer one station's signal over others—experiment with different emulations.

Why the 2019 browser requirement?

WebAssembly and AudioWorklet support became reliably available around this period. Older browsers lack the real-time audio processing capabilities required.

Is the time actually accurate?

The NTP-like network synchronization is typically accurate to within tens of milliseconds—far better than the second-level precision that radio-controlled clocks display anyway.

Conclusion: Your Phone Was Hiding This All Along

Time Station Emulator represents exactly the kind of engineering that makes technology exciting again—not bigger specs or faster processors, but genuine ingenuity applied to unlock hidden capabilities in devices we already own.

The project at https://github.com/kangtastic/timestation turns a frustratingly common problem—dead atomic clocks in signal-poor areas—into a solved problem with zero hardware investment. It does so by understanding digital audio at a level deep enough to make its imperfections into features.

Is it a perfect replacement for real radio time stations? No. The range limitations are real and intentional. But for the millions of clocks sitting desynchronized on nightstands worldwide, it's a resurrection tool of surprising elegance.

My recommendation? Bookmark https://timestation.pages.dev/ before you need it. Test it with a clock you own. Understand how it works. Because the next time someone complains about their "atomic" clock never setting itself, you'll have a solution that sounds like science fiction but runs in any browser.

The best hacks don't require new hardware. They require seeing possibilities that the designers never intended. Time Station Emulator is a masterclass in that perspective.

Go try it now. Your dead clock is waiting.