twinbfield

Software-defined radio and the idyllic beauty of the electromagnetic spectrum

2026-07-09T02:00:00Z

We take for granted the level of interconnectedness we share with the world. The Internet is no longer the source of inspiration it used to be. We've largely moved on from the era of design inspired by a global village-style utopia that dominated tech design in the late 90s and early 2000s, (including, for example, the Frutiger Aero design language that inspires this site's looks). Near-instantaneous connection on a global scale had become more of a monolithic presence, mirrored by the rise of social media platforms and tech giants like Meta, Google, and Apple and demonstrated in the more minimalist and functional design of the 2010s.

But have you ever stopped to think about the physical processes that enable that level of communication? All of the wireless technologies connecting us use radio signals. WiFi, Bluetooth, 5G phone signals, GPS - they are all just different patterns of frequencies occupying portions of the electromagnetic spectrum. If you want to explore the radio spectrum and open a vast network of communications, you can easily do it using something called a software-defined radio (SDR). These are USB receivers the size of a thumb drive that you connect to an antenna - you can get a complete kit for about $50. A software-defined radio can connect you with a near-instantaneous network of worldwide communication - free of charge, free from censorship, free from any platform.

I want to point out that some of the best signals worth accessing are from amateur radio hobbyists (AKA ham radio). Now, when someone says "ham radio", I immediately think of a bunch of old men sitting around microphones complaining about doctors appointments. And sure, there's some validity to that stereotype - listen in on a random conversation happening on the voice bands and more often than not they're talking about the weather, their health, or their equipment. But if you stay with me, I think you'll find that there's a lot more than the stereotype suggests with amateur radio. It's accessible, and it's worldwide. You don't need to be licensed in order to listen in (though you do need a license to transmit). Amateur transmissions can't be encrypted (though they can be encoded, e.g. with Morse code), so you can see anything your antenna can catch. Amateur radio gets a decent chunk of the highly-valued electromagnetic spectrum, and I seriously underestimated the variety of activity going on in the air.

First, then I'll give a brief overview of how you can set this up for yourself or even access someone else's setup via the Internet for free, and then I'll highlight some specific examples of what's out there.

The setup

Using someone else's radio

This is the simplest solution, and it's free. Many enthusiasts make their radios available to the Internet, and there's usually a web interface that will allow you to sweep different frequencies and decode different types of transmissions. I suggest looking on rx-tx.info/map-sdr-points, receiverbook.de, and websdr.org. They support different ranges of frequencies depending on the antenna - for long-distance communication, try the HF ("high frequency") band around 3-30 MHz. Local communications, broadcast FM radio and TV signals are in the VHF ("very high frequency") band around 30-300 MHz. Signals like GPS, WiFi, walkie-talkies, and other close-range radio services occur on the UHF ("ultra high frequency") band in 300-3000 MHz.

Setting up your own radio

You can order a software-defined radio dongle in a kit for about $50. I bought an RTL-SDR v4 from RTL-SDR, though I think this brand and model is becoming difficult to source in the US. If you buy a kit, it might come with a pair of rabbit-ear antennas. Usually, these are good for use within the VHF and UHF bands.

If you want to catch long-distance signals, you'll need an HF antenna. The easiest setup is a random wire antenna - literally a length of wire with a length chosen so that it's not too resonant on any single frequency. I strung 35.5 feet of 14 gauge copper wire around the edge of my ceiling (any wire from the hardware store will do) and connected it into a 9:1 balun, which is an electronic circuit that will make the impedance of your antenna appropriate for the software-defined radio dongle. Instead of grounding the other side of the balun into my apartment's noisy ground, I laid another 10 feet of copper wire on the floor, called a counterpoise. This antenna would probably do much better outside where there's not as much electromagnetic noise, but in an apartment, it works just fine for my purposes.

No matter which antenna you use, you can use something like SDR++ to access the signal on your computer. If you want to decode a digital mode, you will need to pipe the sound into a different program. An alternative is OpenWebRX+, which can provide a web interface with all of the decoding programs for common digital modes, and it's easy to host - I run mine on a Raspberry Pi!

What's out there?

Scroll around on the spectrogram you see, called the waterfall. Some programs like OpenWebRX+ will label specific frequencies of interest, and even pull up decoding programs for digital modes if you click on them.

Broadcast radio and TV

Maybe this is obvious, but you can see broadcast FM and AM radio on the waterfall. These are great to test your setup - you can receive FM radio on ANY antenna. Your software should provide an AM or FM mode. Play with the bandwidth and any denoise/squelch features that your software might provide. People have even reverse-engineered HD Radio if you want to listen to extra channels from one station. On the HF bands, you can also checkout shortwave radio. With the rise of Internet radio stations and music streaming, shortwave stations are not as popular as they used to be, but it requires no Internet access and can be received worldwide.

TV signals are also sent over the air on the VHF/UHF frequencies, though the channels are all over the place. Unfortunately, the bandwidth of my software-defined radio dongles is not high enough to decode TV, but yours might be!

Amateur radio - voice modes

This is what you think of when you think of ham radio. There's probably someone calling "CQ" searching for contacts around the 20m band (about 14 MHz) if you scroll around. Use the USB or "upper sideband" modulation mode, adjust the center frequency and bandwidth, and you should be able to hear someone talking!

If you are interested in hearing what's going on locally, you'll likely want to tune into a repeater. These are regional towers that retransmit received signals on specific frequencies. Multiple towers may be linked together. Find one close to your antenna's location on Repeater Book. These will be somewhere in the VHF/UHF range, and FM modulation is more typical. Check if there's a regular meeting for this repeater, called a net.

Amateur radio - digital modes

Digital modes are really powerful and efficient, as they can compress information and include checksums to ensure accurate reception. One of the most commonly used across several bands is FT8. On 20m, check out 14.075 MHz using an FT8 decoder like the one included in OpenWebRX+ or WSJT-X. These send extremely minimal information - typically, just someone's call sign, who they are responding to, and a 4-letter Maidenhead grid locator that describes their location on the globe.

FT8 is very resilient - you could practically catch these signals on a fork if you hold it high enough. OpenWebRX+ will even map out signals you receive - I'm able to receive signals from Russia and Saudi Arabia on my noisy random wire. Once, I received a signal from Antarctica, and after triple-checking the call sign, sure enough, it was from a German research station!

Amateur radio - SSTV images

One of my favorite signals to receive is slow-scan TV or SSTV. These are images that take a minute or two to receive. You can find them on 20m at 14.230 MHz, but satellites and the International Space Station will occassionally send them on the VHF bands. Like FT8, these need a program to decode them. The first time I got one of these signals to decode, I let out a scream that can only be described as the noise Lucille Bluth makes on Arrested Development when Gene Parmesan does a reveal. Here's an example of a signal I've received on my antenna, though image quality varies a lot for me based on the noise floor in my apartment.

Time and weather

You can hear the weather on a local frequency on the VHF bands using FM! Check out the NOAA Weather Radio stations for your local frequency. The NIST radio stations send out time information and clicks every second.

Mysterious signals

Not all signals on the waterfall are something meaningful - it could just be your washing machine inducing some currents on your antenna! But figuring out mystery signals can send you down the rabbit hole. For instance, you can check out a very cryptic Russian station called the Buzzer.

What's next?

I suppose the next step is to participate in the conversation. Maybe I'll sit for an amateur radio exam and get licensed one of these days. I don't have the funds for a fancy setup, but hams are creative - a halfway decent transceiver and two Slinkies can transmit a signal even from inside a house.

There's something about the radio that keeps bringing me back. Sure, I have an electrical engineering degree, so something about the signal processing and electronics piques my interest, but there's something more fundamental. These signals are flying around us all the time. Can you tell that someone from Quebec is saying hi to someone in Sonora? There's a picture of a frog someone took on vacation flying by - can you catch it?

Theremin 1 - Ultrasonic sensor

2026-06-14T19:21:00Z

There is a wonderfully ethereal instrument called the theremin that is played without touching anything. Built using two antennas (one for volume and one for pitch), it creates a synthesized wave that sounds otherwordly:

Your browser does not support the audio element.

The original instrument is designed as a large capacitive sensor. As the distance between your hand and a charged conductor changes, it changes the frequency of an oscillating circuit. However, since the 1920s when the theremin was invented, there are many different ways to create a theremin that incorporate modern sensors and microcontrollers. Theremin World has dozens of designs.

In this next series of posts, I want to explore three theremin designs. First, I will use an Arduino and an ultrasonic sensor to measure distance and produce a pitch-only theremin. In future posts, I hope to create a "true" theremin based on capacitive sensing, and finally one using circuits only with no microcontroller (if I am brave enough).

Materials and design

For this project, we need the following:

Arduino (I used an Uno)
HC-SR04 ultrasonic sensor
3W 8Ω speaker
LM386 amplifier board (not just the raw LM386 chip)
Various jumper cables and a breadboard

You could easily substitute the type of speaker or amplifier board. When we wire everything together, we need to make sure that the speaker is connected ONLY to the amplifier so we don't accidentally pull a ton of current on the Arduino. Here's the schematic:

Testing the ultrasonic sensor

First, I made a quick script to get the distance from the ultrasonic sensor. I'm summarizing info from another tutorial, but the ultrasonic sensor sends out a pulse on the trigger pin, and you can read how long it takes for the pulse to return. Then, the distance from the sensor to your hand is the time multiplied by the speed of sound over two (since the wave traveled there and back).

// See https://projecthub.arduino.cc/lucasfernando/ultrasonic-sensor-with-arduino-complete-guide-284faf

const int TRIG_PIN = 9;
const int ECHO_PIN = 8;
float timing = 0.0;
float distance = 0.0;
char buffer[40];

void setup() {
  pinMode(ECHO_PIN, INPUT);
  pinMode(TRIG_PIN, OUTPUT);

  digitalWrite(TRIG_PIN, LOW);

  Serial.begin(9600);
}

void loop() {
  // Send a pulse and measure the timing
  digitalWrite(TRIG_PIN, HIGH);
  delay(10);
  digitalWrite(TRIG_PIN, LOW);

  timing = pulseIn(ECHO_PIN, HIGH);
  distance = (timing * 0.034) / 2;

  Serial.print("Distance: ");
  Serial.println(distance);
}

Making the theremin sing

Now, we can set up the theremin entirely. To synthesize a sound on the speaker, we use Mozzi, which allows us to take advantage of the pulse width modulation available on pin 9.

To avoid blocking the audio synthesis, we put all of the logic in the updateControl function. We also provide a moving average for the pitch and the volume so that there isn't awkward clipping and noise in the output.

#define MOZZI_CONTROL_RATE 64
#include <Mozzi.h>
#include <Oscil.h>
#include <tables/sin2048_int8.h>
#include <RollingAverage.h>

const int TRIG_PIN = 7;
const int ECHO_PIN = 8;
const int ECHO_TIMEOUT = 6000;

const float LOW_FREQ = 220; // A3
const float HIGH_FREQ = 880; // A5
const float MAX_DIST = 50.0; // cm
const float MIN_DIST = 5.0; // cm

float timing = 0.0;
float distance = 0.0;
float freq = 0.0;
float freq_avg = 0.0;
float volume_avg = 0.0;
float volume = 0.0;

Oscil <SIN2048_NUM_CELLS, MOZZI_AUDIO_RATE> aSin(SIN2048_DATA);
RollingAverage <int, 16> kAverage_freq; // Average across 16
RollingAverage <int, 16> kAverage_vol;

void setup() {
  startMozzi();
  aSin.setFreq(LOW_FREQ);

  pinMode(ECHO_PIN, INPUT);
  pinMode(TRIG_PIN, OUTPUT);

  digitalWrite(TRIG_PIN, LOW);

  Serial.begin(115200);
}

void updateControl(){
  // Send a pulse and measure the timing
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  timing = pulseIn(ECHO_PIN, HIGH, ECHO_TIMEOUT);
  distance = (timing * 0.0343) / 2;
  
  // Map onto frequencies
  float volume;
  if (distance <= MIN_DIST) {
    volume = 0.0;
  } else {
    volume = 1.0;
  }
  float freq = ((distance - MIN_DIST) / (MAX_DIST - MIN_DIST)) * (HIGH_FREQ - LOW_FREQ) + LOW_FREQ;
  freq_avg = kAverage_freq.next(freq);
  volume_avg = kAverage_vol.next(volume);

  aSin.setFreq(freq_avg);

}

AudioOutput updateAudio(){
  return MonoOutput::from8Bit(aSin.next() * volume_avg);
}

void loop() {
  audioHook();
}

Loading this onto our board, we can produce a sound! The potentiometer on the LM386 amplifier can help control the volume.

Your browser does not support the audio element.

Very nice! Now, as a musician, this instrument overall is... okay. I could probably improve the synthesis - it's a bit laggy with the averages, and it's a bit sensitive when the sensor doesn't detect your hand. Stay tuned for the second design, based on capacitive sensing with an antenna!

License

The schematic was created with Fritzing. The LM386 amplifier schematic was modified from the Arduino library. Both are released under CC BY-SA 3.0.

Evennia cheat sheet

2026-05-26T02:47:00Z

I'm creating a MUD using Evennia, a Python framework that is super powerful and extendable. I couldn't find a great cheat sheet online, so here's some notes from their tutorial series. I will update this as I go, and I may end up typesetting this into a PDF.

Evennia commands

These commands are done through the Evennia shell (i.e., through a MUD client). Typically, items can include me for oneself, here for the current location, or a database reference number like #8.

Basic interaction

Operation	Code
Get help	`help [item]`
Look around	`look [item]`
Get detailed information	`examine [item]`
Pick up item	`get [item]`
See inventory	`inventory`
Use a named exit	`<exit>`
Move to a location	`teleport <location>`
Global search for something	`find <item/location/exit...>`

Creating items

Operation	Code
Create an item (and drop it)	`create[/drop] <item>[:<typeclass]`
Add synonyms	`name <item> = <alias>[;<alias>...]`
Add descriptions	`desc <item> = <details>`
Move item to a location	`teleport <item> = <location>`
Delete item	`destroy <item>`
Set attribute	`set/<attribute> = <name>`

Creating locations

Operation	Code
Add a named location from here	`dig <location> = <exitname>[;<alias>...]`
Add a cardinal direction	`tunnel <n[orth]/s/e/w/nw/.../in/out/up/down> = <name>[;<alias>...]`
Open from here to a previous location	`open <exitname>[;<alias>...] = <location>`

Administration

Operation	Code
Temporarily decrease/restore permissions	`quell/unquell`
Add help entry	`sethelp <entryname> = <details>`
Reload world and code	`reload`

Locks and permissions

Lockfuncs can be defined in server/conf/lockfuncs.py. See Evennia's list of access_types.

Operation	Code
Add/remove lock	`lock[/del] <object> = <lockstring>`
Lockstring format	`<accesstype>: [NOT] lockfunc() [[AND/OR] [NOT] lockfunc() ...]`
Add/remove account permissions	`perm/account[/del] <user> = <permission>`
Account levels	Guest, Player, Helper, Builder, Admin, Developer
Add/remove object permissions	`perm[/del] <object> = <permission>`

Python commands

These commands can be used in the interactive Python shell (py within a MUD client) or through a Python script.

Creating things

Operation	Code
Create a character, room, exit, or object	`evennia.create_object('<typeclass>', key='<database_key>', [location=...,] [permissions=...,] [locks=...,] [attributes=...,])`
Store persistent object values	`<object>.db.<key> = ...`
Creating an account, channel, or script	`evennia.create_<account/channel/script>(...)`
Object location	`<object>.location`
Object contents	`<object>.contents`
Exit destination	`<exit>.destination`
Add tags	`<object>.tags.add("<tag>"[, category="<category>"])`

Creating commands

Operation	Code
Name of command	`<Command>.key`
Command function	`<Command>.func()`
Argument string provided to command	`<Command>.args`
Help function for command	Defined in docstring of `<Command>`
Message command caller	`<Command>.msg("<msg>")`
Add command to a commandset	`self.add(Command)` in `<CmdSet>.at_cmdset_creation()`
Remove command from a commandset	`self.remove(Command)` in `<CmdSet>.at_cmdset_creation()`

Searching

See the Evennia docs on Django queries for an explanation on how powerful and flexible Django queries can be.

Operation	Code
Global search for an object	`evennia.search_object("<name>")[0]`
Search for an object relative to caller	`<object>.search("<name>")`
Search by tag	`evennia.search_tag("<tag>")`
Search by location	`evennia.search_object("<name>", candidate=<location>.contents)`
Search by attribute	`evennia.search_object("<name>", attribute_name="<attribute>")`
Search by typeclass	`evennia.search_object("<name>", typeclass="<typeclass>")`
Search by Django query	`<Typeclass>.objects.<all/filter/get/exclude(db_key="<name>")>`
Search by Django query (incl. subclasses)	`<Typeclass>.objects.<all_family/filter_family/get_family/exclude_family(db_key="<name>")>`

Directories

Directory	Description
`commands/`	Commands and command sets
`server/`	Server files, see settings at `server/conf/settings.py`
`typeclasses/`	Templates for accounts, characters, scripts, rooms, etc.
`web/`	Website and webclient files
`world/`	Misc. files, useful for user-defined build scripts and modules

How to start a blog

2026-05-24T19:00:00Z

I'm starting a webring with some friends called the Combo Crew, so I put together this guide on how to start a blog and connect it to the ring.

1. Getting a website running

To start out, let's clarify something about running a website. There are two things that must happen for a website to appear on the Internet: first, you must have your website hosted somewhere (i.e., a publicly-accessible server on the Internet stores your content). Second, there must be a domain name like google.com or tilde.club that is registered and points to wherever your site is hosted.

It's not necessary to spend money to do either of these things. There are many services that will offer free hosting for your website if your website is static and only serves content like images and text and does not involve any server-side scripting. Many of these sites will also give you a free subdomain for your site. For example, GitHub Pages hosts many static sites that look like <something>.github.io - take a look at netflix.github.io. If you want something that looks like example.com, you need to buy a domain name. Buying and registering a domain name is going to be out of scope for this blog post, but know that it costs about $12-$20 USD/year, though having a domain name allows your identity and site to be independent of any specific host if you want to swap around.

Now, that's all great, but how do you actually go about building your website? Here, you have a couple options depending on your website host. If you want to avoid messing with HTML or CSS, go with a blog host that allows you to post using a graphical interface. I recommend looking at bearblog.dev or i.haza.website. Wordpress.com and blogger.com are some of the big names in blogging software, too. Substack can even work as a blog. Just note that some of these more user-friendly options lock some options behind a paywall, such as connecting your site to a registered domain name.

If you want a bit more control over your site and how it looks, I recommend looking into static site generators like Eleventy and Jekyll. These are programs that build your site by Markdown posts with reusable templates. There are endless, beautiful templates that people have created for you to use, along with great tutorials. This option can, however, be a bit more technical - though AI can help clarify how to use or generate templates. If you don't know how to use GitHub or a command line, it's probably best to avoid these for now.

tl;dr - Find a free blog host that uses a graphical interface. I like bearblog.dev.

2. Connecting to the blogosphere

In my opinion, your website is not a blog until you give people a way to follow your blog. In the blogosphere, the most common solution is something called an RSS feed or an Atom feed. These are sidecar files that list all of your posts and some important metadata. Software called feed readers can poll all of the feeds that you follow and provide you with all of the most recent updates. RSS/Atom feeds are decentralized, unlike social media. These feeds are usually indicated by a syndication symbol:

Usually, whatever software you are using to write a blog will generate an RSS feed or Atom feed automatically, and it should have the link somewhere on the front page. Usually, the feed is stored at example.com/feed.xml or something similar. If you are using a blogging software with a graphical interface, check the documentation to make sure they provide a feed. If you are using a static site generator, typically a plugin will generate a feed for you. People follow your blog by putting the link to the feed into their feed reader. If you want to try following blogs using a feed reader, I've used Feedly and Fluent Reader.

Another cool way of connecting with the blogosphere is connecting to a webring. These were popular back on the early Internet, and it's basically just a linked list of sites on a related topic. They are becoming increasingly popular again as people reconnect with personal websites. For example, check out all of the webrings on this aggregator.

By way of example, the Combo Crew has an invite-only webring. To join the webring, you put this HTML code somewhere on your front page. Replace the ?via= to a url-encoded version of your URL:

<center>
<!-- Begin Combo Crew Webring Badge -->
<a href="https://webri.ng/webring/combocrew/next?via=https%3A%2F%2Ftilde.club%2F~twinbfield">
<img src="https://tilde.club/~twinbfield/assets/combo_crew_88x31_blue.png" border="0" width="88" height="31" alt="Combo Crew Webring" />
</a>
<!-- End Combo Crew Webring Badge -->
</center>

(You can replace the color on the PNG link. Options are red, orange, yellow, darkgreen, lightgreen, blue, pink, and purple.)

Then, message me the URL of your site, and I'll add it to the webring. The 88x31 button should take you to the next site in the webring.

tl;dr - Make sure you have a link to an RSS or Atom feed so people can follow your blog.

3. What's next?

Now, you can post! For Combo Crew specifically, we're looking at starting something like a blog carnival, where someone hosts a theme and writes a summary post aggregating (and linking to) the individual blog posts. Consider adding top-level pages like an "About" page or an "Interests" page to orient people on your site. Link to other videos, sites, and posts you like with a blogroll.

If you are technically inclined, you may enjoy tinkering with your website. For example, you may want to add a comment system if your blog does not already support it (see Giscus and Webmentions for ideas). The IndieWeb has tons of ideas on how to use your site as your online identity. For example, you can use Bridgy and Bridgy Fed to have posts from your site automatically syndicated out to social media and pull comments/likes back in to your site.

There's also some more niche and lively communities to explore. For example, tilde.club where this site is hosted, is what's called a pubnix, meaning the community exists on a shared Unix server. Pubnixes typically offer free web hosting along with different protocols like Gemini and Gopher, and the ability to do some light server-side scripting. Some tilde-style pubnixes offer open sign-ups, while others like sdf.org and freeshell.de require verification by physically mailing something to an address. There's also Neocities and 32bit.cafe that aim to support people in creating personal websites, often with very artistic and retro theming.

tl;dr - Post! Tinker! Explore! Decorate! Design! Build the web you want to see!

How I've set up a password manager, and why you should too

2025-10-09T00:00:00Z

The need for password managers

Humans are extremely predictable. For example, when asked for a random number, a study showed that most people will choose seven. If you take a look at Wikipedia's compilation of most commonly used passwords, the top contenders are pitifully predictable. Passwords like "123456", "iloveyou", "qwerty", and yes, even "password" are still common in the year 2025. We are understandably tired, and no one wants to remember a million passwords for a million applications.

More and more sites and applications are aware of this issue. We've seen a huge rise in sites using OAuth, where sites can delegate authorization to an authority like Google or GitHub, allowing third parties to verify identity without seeing the password. These are great, but they leave the responsibility for your credentials tied to a specific authority. While there is a push for federating the OAuth authority to one's own domain with IndieAuth, this practice is not yet widespread, though I am interested in looking more into it.

Another solution is using a password manager, where you access a database containing all your passwords using one strong master password. Many people should be used to the password managers that come built in to smartphones. These are convenient, but not very portable to multiple devices, especially outside of the corporate ecosystem containing the manager (cough, cough Apple passwords).

Web-based password managers like NordPass and LastPass offer a temptingly convenient solution, but these password managers also place trust in a corporate entity's security practices, potentially for a fee. While handy, multiple security incidents at LastPass encouraged me to find a better solution.

My solution with KeePassXC

I use KeePassXC to manage my passwords. You create a database, choose a strong master password to memorize, and you can store all of your passwords in an encrypted database. I chose KeePassXC so I can access my database from a similar client on macOS, Windows, and Linux. And, it's available as free software (as in price and as in freedom)! There are many tutorials available online that are much more thorough, so I won't cover details here, but I will provide an overview of what I've found works for me.

KeePassXC can generate extremely strong and long passwords (even including extended ASCII symbols that no sane person would type into a password box). You won't need to remember the password, just the master password for the database!

KeePassXC can also integrate into your browser. There is an extension for Firefox and Chrome (and Edge) that will integrate the passwords automatically into password fields on web pages. I've hooked it up to the fingerprint reader on my laptop so I can open the database with my fingerprint. You can use a key file or hardware key if you are feeling the need to be particularly secure.

In order to have my database available across multiple devices, I store the encrypted database on Google Drive, though I'm in the process of looking for a different place to store my files on the cloud. I can even set it up on my iPhone using Keepassium, though notably this app is not free software, and free users are limited to a single database. A tip if you use this method: make sure to check the "Use alternative saving method" and "Directly write to database file" on your KeePassXC settings if you are syncing through Google Drive. Otherwise, I found Keepassium doesn't update to the newest version of the database and points to the recently deleted version.

One warning is that you must remember your master password. If you forget the master password, the database is completely irretrievable. If there were another way to get the database unlocked, it wouldn't be very secure!

I hope you consider using a password manager!

Introduction

2025-09-10T00:00:00Z

Welcome! My name is twinbfield. This is a space where I explore retro computing and niche corners of the Internet. I aim for posts to be quick, text-focused reads over extended explorations. Consider adding this site to your feed aggregator to get updates.

I plan to use this site to experiment as well. As of writing, I'm currently hosted on tilde.club. I also want to try providing content over other protocols like Gopher and Gemini. You can check out some of my previous tinkering outcomes - there's mini games I've made posted under Demos and Games.

For the technically interested, this site uses the 11ty site generator with a fairly barebones template I have been putting together. I've chosen to release content that I have generated on this website under the CC BY 4.0 license.

I'm working on a solution for comments. Stay tuned!

twinbfield

Software-defined radio and the idyllic beauty of the electromagnetic spectrum

The setup #

Using someone else's radio

Setting up your own radio

What's out there? #

Broadcast radio and TV

Amateur radio - voice modes

Amateur radio - digital modes

Amateur radio - SSTV images

Time and weather

Mysterious signals

What's next? #

Theremin 1 - Ultrasonic sensor

Materials and design #

Testing the ultrasonic sensor #

Making the theremin sing #

License

Evennia cheat sheet

Evennia commands

Basic interaction #

Creating items #

Creating locations #

Administration #

Locks and permissions #