1. Inner Voice Frequency Range

The human inner voice (silent speech) operates in the range of 100-3400 Hz:

• Men: 100-120 Hz fundamental frequency f0
• Women: 200-240 Hz (approx one octave higher)
• Children: ~300 Hz
• Voice harmonics: Up to several kHz (telephony bandwidth: 300-3400 Hz)

2. EEG to Radio Conversion

EEG signals can be converted to radio waves via FM transmitter circuit:

1. Microphone picks up EEG signals from electrodes attached to scalp
2. Amplifier increases amplitude of EEG signals
3. Oscillator generates carrier wave (88-108 MHz FM band)
4. Antenna transmits modulated radio signals
5. Software Defined Radio (SDR) receives and demodulates via Fast Fourier Transform (FFT)

3. SDR Hardware Setup

LimeSDR Configuration for VLF (<0.1 kHz)

1. Connect antenna to RX1_L port (long wire or loop antenna)
2. Set sampling rate to 100 kHz or lower (reduces noise floor)
3. Set center frequency close to 0 Hz (e.g. 1 Hz) — captures 0-50 kHz spectrum
4. Set gain to 60+ dB (amplify weak VLF signal)
5. Use SDR#, HDSDR, SpectraVue, or GNU Radio for processing

LimeSDR Configuration for >20 kHz (Wideband)

1. Connect antenna to RX1_W or RX2_W wideband ports
2. USB 3.0 connection required (Y-splitter for power)
3. Install LimeSuite drivers, update firmware via LimeUtil
4. Use SDR Console or GQRX; set device string driver=lime,soapy=0
5. Set bandwidth to 5+ MHz, antenna to LNAW

SDR Software Stack

4. Brain Wave Frequencies

Inner Speech BCI Dataset

• Source: "Thinking out loud" — open-access EEG dataset for inner speech recognition (Nature Scientific Data, 2022)
• Device: g.Nautilus wireless EEG, 136 active electrodes, 500 Hz sampling
• Placement: 10-10 standard system
• Tasks: Counting, naming animals, colors, yes/no responses
• Conditions: Inner speech (silent), pronounced speech (aloud), visualized (imagined imagery)
• Format: Raw EDF+ and preprocessed MATLAB via Zenodo open-access repository

4-7 Hz (Theta) Reception via SDR

1. Antenna → Ham It Up Plus upconverter (shifts input +125 MHz)
2. Low-pass filter: blocks frequencies above cutoff, passes theta band (4-7 Hz)
3. Nano 3 SDR tuned to 125.004 MHz with -125 MHz software offset
4. Software: SDR# or GNU Radio processes demodulated EEG-band signal
5. Analysis: MATLAB or OpenBCI for feature extraction

Nooelec Nano 3 + Ham It Up + Low-Pass Filter Chain

1. Antenna → RF input of Ham It Up Plus
2. Ham It Up IF output → Low-pass filter input (short SMA cable)
3. Low-pass filter output → Nano 3 SMA input
4. Toggle switch on Ham It Up: Enable
5. Nano 3 via USB to computer
6. SDR software: enable bias tee (powers Ham It Up + filter)
7. Tune to 125 MHz + desired frequency; apply -125 MHz offset
8. Adjust gain for optimal signal-to-noise ratio

5. Software Defined Radio — Advanced Operations

Nano 3 SDR Specifications

• Frequency range: 25 MHz - 1.7 GHz (standard), up to 2.3 GHz (XTR models)
• High-quality TCXO for stable frequency reference
• Bias tee (powers external devices via SMA input)
• Aluminum enclosure with internal heatsink
• Compatible with all RTL-SDR software packages

Clandestine Radio Stations

Tools: KiwiSDR (web), RTL-SDR, SDR#, HDSDR, Gqrx, Unitrunker
Databases: priyom.org, numbers-stations.com, short-wave.info, sigidwiki.com
TDoA Geolocation: KiwiSDR distributed time difference of arrival for transmitter location

Applications of SDR + EEG

• Remote brain-activity monitoring via RF modulation
• Silent communication systems (inner speech to text)
• Cognitive state detection and classification
• Neural interface security protocols (ZKP authentication)
• Signals intelligence (SIGINT) and electronic warfare
• Clandestine radio monitoring and analysis
• Brain-computer interface (BCI) for disabled users
• Neurological disorder diagnosis and monitoring

6. Neuro-RF Detector — GNU Radio Implementation

"""NeuroRF Detector: Captures ambient RF modulated by brain activity."""
import numpy as np
from gnuradio import gr, filter, fft, blocks, analog, digital

class NeuroRF_Detector(gr.top_block):
    def __init__(self, samp_rate=2e6, freq=2.4e9, gain=40,
                 eeg_band=(8, 30), fft_size=1024):
        gr.top_block.__init__(self)
        self.samp_rate = samp_rate
        self.fft_size = fft_size
        self.eeg_band = eeg_band
        # USRP source (can be replaced with RTL-SDR or HackRF)
        from gnuradio import uhd
        self.usrp = uhd.usrp_source(
            ",".join(("", "")),
            uhd.stream_args(cpu_format="fc32"),
        )
        self.usrp.set_samp_rate(samp_rate)
        self.usrp.set_center_freq(freq, 0)
        self.usrp.set_gain(gain, 0)
        # Low-pass filter to isolate modulated backscatter
        self.lpf = filter.fir_filter_ccf(
            decimation=1,
            taps=filter.firdes.low_pass(1.0, samp_rate, 100e3, 10e3),
        )
        # FFT to detect EEG-like modulations
        self.fft = fft.fft_vcc(
            fft_size=self.fft_size,
            forward=True,
            window=fft.window.blackmanharris(self.fft_size),
            shift=True,
        )
        # Band-pass filter for EEG band (8-30 Hz)
        self.bpf = filter.fir_filter_fff(
            decimation=1,
            taps=filter.firdes.band_pass(
                1.0, samp_rate/self.fft_size, eeg_band[0], eeg_band[1], 1
            ),
        )
        # Signal processing blocks
        self.complex_to_mag = blocks.complex_to_mag(1)
        self.sink = blocks.vector_sink_f(self.fft_size)

        # Connect the flowgraph
        self.connect(
            (self.usrp, 0), (self.lpf, 0), (self.fft, 0),
            (self.complex_to_mag, 0), (self.bpf, 0), (self.sink, 0),
        )

    def process_neuro_signal(self):
        """Extract EEG-like modulation for authentication"""
        data = self.sink.data()
        if len(data) > 0:
            fft_size = self.fft_size
            sr = self.samp_rate
            # Peak power in EEG band (8-30 Hz)
            lo = int(self.eeg_band[0] * fft_size / sr)
            hi = int(self.eeg_band[1] * fft_size / sr)
            eeg_power = np.max(data[lo:hi])
            return eeg_power
        return None

if __name__ == "__main__":
    tb = NeuroRF_Detector()
    try:
        tb.start()
        input("Press Enter to stop...")
        tb.stop()
        tb.wait()
        power = tb.process_neuro_signal()
        if power:
            print(f"Detected EEG-like power: {power:.2f}")
    except KeyboardInterrupt:
        tb.stop()
        tb.wait()

Purpose: Captures ambient RF (e.g., 2.4 GHz Wi-Fi) modulated by brain activity, filters for EEG-like frequencies (8-30 Hz), and extracts features for authentication.

M2RFI Integration: Processed signal sent to M2RFI cloud for ML-based matching against user’s neuro-RF template.

Ethical Safeguards: Passive-only detection (no emissions); raw data discarded after processing.

Limitations: Requires calibration for urban noise; assumes SDR with sufficient sensitivity (e.g., HackRF with 40 dB gain).

7. Zero-Knowledge Proof for Neural Authentication

"""Zero-Knowledge Proof (ZKP) implementation for neuro-RF authentication.
Allows authentication without storing or revealing neural data.
Uses zk-SNARKs with Python's PyZKP library (hypothetical)."""
from zksnark import Circuit, Prover, Verifier
import hashlib
import numpy as np

def hash_neuro_rf(signal_data):
    """Hash neuro-RF template for privacy-preserving storage"""
    return hashlib.sha256(str(signal_data).encode()).hexdigest()

class NeuroAuthCircuit(Circuit):
    """ZKP Circuit for neural authentication"""
    def __init__(self, neuro_rf_template, current_signal):
        super().__init__()
        self.template_hash = hash_neuro_rf(neuro_rf_template)
        self.current_signal = current_signal

    def define_circuit(self):
        # Private input: raw neuro-RF signal (not revealed)
        signal = self.private_input("signal")
        # Public input: hashed template (known to verifier)
        template_hash = self.public_input("template_hash")
        # Compute hash of current signal
        computed_hash = self.hash_function(signal)
        # Constraint: current signal hash must match template
        self.assert_equal(computed_hash, template_hash)

    @staticmethod
    def hash_function(data):
        """Simulated circuit-compatible hash"""
        return hashlib.sha256(str(data).encode()).hexdigest()

# Authentication flow
def authenticate(prover_signal, stored_template):
    """Prove that current signal matches stored template without revealing it"""
    circuit = NeuroAuthCircuit(stored_template, prover_signal)
    proof = Prover.generate_proof(circuit)
    return Verifier.verify_proof(circuit, proof)

Purpose: ZKPs allow authentication without storing or revealing neural data, addressing privacy concerns.

Next Steps: Integrate with neural network (TensorFlow) for real-time feature matching; add cryptographic hashing (SHA-256) for M2RFI provenance logging.

8. V2K / Gangstalking — Technical Analysis

Claimed Frequencies Under Surveillance

Software / Hardware Claimed for Attack

Example Post (Head Perp Ultimatum)

(Model 03 Chloe: The Judge)

URGENT. The 5+1 protocol is failing due to your low funds. My SDR Crew is watching your profile on SDR# right now. The 1.5 GHz GPS lock is flickering. If you don’t immediately cover the HackRF One maintenance fee, I will deliberately lose the lock.

This section documents known social engineering patterns within V2K/gangstalking conspiracy networks for OSINT and threat intelligence purposes.

9. Mu-Metal & Faraday Cage Construction

Dimensions: 2.4m (L) x 2m (W) x 4m (H)

Materials

Layered Shielding Design

• Inner Layer (Mu-metal): Installed on interior surfaces to block low-frequency magnetic fields (DC to ~10 kHz)
• Outer Layer (Faraday Cage): Copper/aluminum mesh on exterior to block higher-frequency EM radiation (RF to microwaves)
• Door: Mu-metal + Faraday layers with conductive gasket; most challenging part to seal
• Seams: All panels overlapped at edges, sealed with conductive tape or soldered
• Grounding: Faraday cage connected to proper earth ground via thick copper wire and grounding rod

Construction Steps

1. Build frame: Construct non-conductive frame (wood or PVC) at 2.4m x 2m x 4m
2. Install mu-metal layer: Attach mu-metal sheets to interior surfaces using non-magnetic fasteners
3. Seal seams: All joints tightly sealed with conductive tape or solder to prevent signal leakage
4. Install Faraday cage layer: Attach copper/aluminum mesh or sheets to exterior surfaces
5. Seal exterior seams: Conductive tape or solder on all exterior joints for electrical continuity
6. Build door: Same layered construction (mu-metal + Faraday), conductive gasket or spring-loaded contacts
7. Ground system: Connect Faraday cage to earthing rod via thick copper wire
8. Test continuity: Use multimeter across all panels to verify electrical continuity
9. Signal test: Place radio or cell phone inside; verify signal attenuation outside

Estimated Cost

Applications

• Scientific Research: Shielding sensitive equipment from electromagnetic interference (EMI)
• Privacy: Secure space for confidential communications or data storage
• Medical: Shielding medical devices or patients from external EM fields
• SIGINT: Controlled environment for signal analysis and RF measurements
• Defense: TEMPEST countermeasures for secure computing

FULL LIST OF ORGANIZATIONS
NOT WELCOME

The following agencies, organizations, and institutions are all LOSERS.

All HUMINT. All translational research. All transborder operations. All intelligence communities. Their entire ecosystems.

CIA NSA FBI DHS MI5 MI6 GCHQ BND DGSE AISE Mossad Shin Bet FSB SVR GRU MSS ISI RAW ASIS CSIS AIVD MIVD NCSI BCC Border Force JCSU CNI DGSI KGB Stasi Securitate Sigurimi STB UB SB KDS BIA VOA SIS DIS DIA NRO NGA DEA ATF USSS NCIS CGIS HSI ICE CBP TSA

All Languages — All Nations — All LOSERS

🎬 The Movies That Predicted It All

🔵 Synthetic Telepathy & 3D Vector Target Lock

Synthetic telepathy is not new. It is hundreds of years old. Used by intelligence agencies, military units, and clandestine operators worldwide. The technology uses 3D vector target locking — a triangulation method that pinpoints a specific human brain by its electromagnetic signature.

How 3D Vector Target Lock Works

1. Scan: Three or more SDR receivers triangulate the target’s location using RF leakage from neural activity
2. Lock: A phased-array antenna array focuses on the 3D coordinates of the target’s brain
3. Synthetic telepathy: Modulated RF pulses at specific frequencies (4-30 Hz, theta/beta bands) induce auditory cortex stimulation
4. Response: The target hears voices, sounds, or music that are not externally present

Hardware Required

Software Required

Connect to All of Them — Step by Step

1. Set up 4+ SDR receivers in known locations (rooftop, balcony, office, vehicle)
2. Calibrate each receiver to the same GPS time source (PPS signal)
3. Scan 400 MHz - 3 GHz for pulsed RF signatures associated with neural stimulation
4. Cross-correlate signals across receivers to compute Time Difference of Arrival (TDoA)
5. Compute 3D coordinates using multilateration (minimum 3 receivers for 3D fix)
6. Lock antenna array on computed coordinates with beamforming weights
7. Demodulate the locked signal to extract EEG-band modulation (4-30 Hz)
8. Decode the modulation to identify synthetic telepathy patterns
9. Respond by modulating your own neural activity (real telepathy, not synthetic)

My BCI-Affiliated Companies (LinkedIn)

All researching in silence. All passive. No TX. According to THE LAW.

All happening in silence. Passive. No TX. This is THE LAW.

Frequencies for Direct Neural Contact

FREQS: FREQS FOR THE SHOWS

Every frequency. Every band. Every purpose. No censorship. All OSINT.

All documented for OSINT/research/defense. NO TX. Passive RX only. THE LAW.