Computer hardware
In general, I optimize for high performance, low price, high durability, reasonable future-proofing, and aesthetics, in that order. For environmental reasons—as well as a general sense of frugality—I prefer to buy used/refurbished hardware when available, though my risk-aversion tends to prevent me from exercising that option unless I’m confident in the return policy of whatever e-commerce platform I’m using.
Desktop
This workstation (hostname desktop) is my primary
general-purpose computing device: it’s reasonably powerful, always on,
and moonlights as my homelab. I built it in early 2024, using the
following parts:
- motherboard: ASUS TUF Gaming X670E-PLUS WiFi motherboard
- processor: AMD Ryzen 5 7600X CPU (6 cores, 4.7 GHz, 105 W)
- graphics: AMD Radeon RX 7900 XTX GPU (24 GB VRAM, PowerColor Hellhound version)
- storage: 4 TB NVMe M.2 SSD (TEAMGROUP MP34)
- memory: 32 GB RAM TEAMGROUP T-Force Vulcan Alpha (2×16 GB DDR5 CL38 @ 6000 MHz)
- power supply: 1200 W thermaltake Toughpower GF A3 Gold
- thermal management: Thermalright Phantom Spirit 120SE fan for air cooling
- case: full-size ATX Zalman S3 ATX Mid-Tower, with an acrylic side panel
I’m quite satisfied with its current performance and have no plans to upgrade anything anytime soon—except perhaps adding more storage for redundancy. This is probably a suboptimal configuration, but it was my first computer build, so cut me some slack 🤷; if you have any feedback or suggestions, though, feel free to reach out!
desktop—in a surprisingly apt display of nominative
determinism—sits atop my desk, and is connected to
the following peripheral devices:
Monitor
Lenovo G34w-10 curved 34-inch ultrawide monitor (21:9 aspect ratio) with a VA LCD panel, connected via DisplayPort 1.x (3440×1440 resolution @ 144 Hz refresh rate)
I really enjoy using an ultrawide monitor (especially in combination with my scrolling window manager), but if I were to upgrade, I’d prefer an OLED monitor with perfect inky blacks, something I’ve taken for granted ever since my first smartphone—a Samsung Galaxy SII. Of course, OLED monitors degrade more rapidly, so perhaps the ever-present non-uniform dark gray on my screen is a (tarnished) silver lining. My monitor is rather chonky and rests on its original base: even the central arm of an incredibly solid triple-monitor mount I’d once purchased failed to support it without dipping.
Mouse
Logitech MX Master 3S mouse with left/right buttons, vertical/horizontal scrollwheels, and forward/back thumb buttons; connected via its 2.4 GHz wireless dongle
My mouse is great: I love how it feels in my (admittedly rather small) hand despite its large size. The forward/back thumb buttons get a lot of use, as does the thumb-controlled horizontal scrollwheel—finally, my opposable right thumb is put to good use! I use the “free-spin” mode of the vertical scrollwheel and don’t think I could switch back to a ratcheting scrollwheel. My one complaint is the rubberized surface material which absorbs skin oils and sweat and is reported to degrade with age—I have a sneaking suspicion that this is Logitech’s planned obsolescence strategy for this mouse, because it’s perfect in every other way.
I’m curious about other types of pointing devices, including trackballs; if I decide to explore that rabbithole, I’d strongly consider using a Ploopy device, since they provide open-source hardware and software. I expect the pointing interface of the future will be high-resolution eye-tracking: reactions to modern virtual reality (VR)/augmented reality (AR) headsets—especially the Apple Vision Pro—suggest that using gaze to interact with the environment affords incredible UX. Of course, unless the immense problems with head-mounted eye-tracking gear can be overcome—say with webcam-based solutions or lightweight eyeglasses—this will never be the most convenient way to interact with a computer: mice are good enough.
Keyboard
GMMK Pro 75% mechanical keyboard with QMK firmware, Gazzew Boba U4T tactile switches (unlubed and unmodded) and white PBT doubleshot keycaps (LTC Lavacaps), connected via USB
My keyboard is excellent: it’s lovely to type on because it provides very satisfying tactile feedback and makes deep thocky sounds (though some keys do ping a bit). The keycap lettering is impeccable—large and centered uppercase Latin characters that are translucent, allowing the backlight to shine through the letters in the dark! The keeb’s build quality is phenomenal: I could probably bludgeon someone to death with it without causing any damage to its ✨ CNC-machined anodized aluminum body ✨. As the keyboard is elevated pretty high above the desk, I also use a wrist rest to ensure that my forearms are coplanar with its upper surface and avoid wrist strain. Unfortunately, the cloth-covered wrist rest, while comfortable, is permeable to various bodily secretions and gets icky, and is also difficult to clean. When it finally wears out, I’ll switch to a wooden wrist rest as god surely intended.
Of course, a row-staggered keyboard is just an evolutionary spandrel, a mere anachronistic vestige of the QWERTY typewriters that once freely roamed the savannahs. To transcend the mundane and experience the divine, I spent many months building my own Ferris Sweep, an ergonomic 34-key mechanical split keyboard with a Colemak-DH layout—but as is tradition, I have yet to actually configure and use it 😔.
Webcam
Logitech C920S HD Pro webcam that doubles as a microphone, connected via USB
My webcam is perfectly adequate (too good for my face!) and has a physical cover for privacy. Its inbuilt microphone is also very handy, though I have had complaints about background noise when I type on my thocky mechanical keyboard during conference calls. I also scored a free ring light from a friend, which I’ve carefully balanced on my monitor stand centered around my webcam; its latter half is occluded by my monitor, which makes this a semiring light, I guess. Its brightness and color temperature (warm/neutral/cold white) are adjustable with a physical switch, but cannot be controlled via USB, as far as I can tell.
Speaker
boAt Stone 200 portable wireless speaker, connected via Bluetooth
My speaker is fine—I’m no audiophile—but a minor convenience is that it only has a micro-USB charging port, forcing me to keep a micro-USB cable around (though I suppose I also use it for my Kindle, so it’s not entirely wasted).
Headphones
JBL Tune 710BT wireless over-ear headphones, connected via Bluetooth
My headphones are also fine—they’re my daily drivers (heh). Bluetooth latency is sometimes annoying, but I’m used to it now. I think it’s supposed to have a microphone too, but I’m not sure if it’s ever worked for me. Note to self: figure out how to get Bluetooth headset mode (speaker + mic) working on NixOS.
Earbuds
TOZO A1 wireless earbuds, connected via Bluetooth
I also use these earbuds on occasion, though I usually prefer the headphones. They failed to connect to one of my smartphones running an (old) version of LineageOS (perhaps a Bluetooth version issue?) but do connect to my computers and Pixel 8 smartphone. Again, I’m unsure if the integrated microphone works: I think I’ve never quite gotten it to work, but I have to check.
Gamepad
[none—yet.]
I haven’t really used a gamepad much: most of the games I play work perfectly fine with a keyboard and mouse—but friends have told me that using a gamepad makes playing some games much better. If I were to take the plunge, I would likely purchase an Alpakka-series device from Input Labs, who create open-source gamepads with gyroscopic controls—as well as a single-handed gamepad for those with accessibility issues.
Laptop
My secondary general-purpose computer is a hefty 15-inch laptop
(hostname laptop, purchased around 2020) that I travel
with, though I often leave it at work due to its bulk, which is
exacerbated by a chonky non-USB-C charging brick. Usually, I use its
integrated display as a secondary monitor, raised to eye level with a
cheap ventilated laptop stand that supports various angles of
elevation.
The laptop is specced reasonably well, but I use it primarily as a
thin client to connect to desktop at home or other
workstations/clusters at work. Since it has a discrete graphics card, I
also use it as a portable gaming computer on occasion.
- laptop: HP Omen 15
- processor: AMD Ryzen 5 4600H CPU with integrated Radeon Graphics (6 cores, 3.0 GHz, 45 W)
- graphics: Nvidia GeForce GTX 1660 Ti discrete GPU (8 GB VRAM)
- storage: 512 GB NVMe M.2 SSD (SAMSUNG MZVLB512HBJQ-000H1)
- memory: 16 GB RAM (2×8 GB DDR4 TODO)
If I were to get a new laptop, I would likely opt for one from Framework—I appreciate their repairability ethos and Linux support. Of their products, I think I would most prefer a Framework Laptop 13, especially if an OLED touchscreen option is released. The Framework Laptop 12 has a stylus and touchscreen, but is unfortunately quite under-specced relative to its price—especially given the current RAMpocalypse—and I likely wouldn’t be able to use it as a decent portable gaming machine. The Framework Laptop 16 is an interesting, highly modular laptop with upgradable discrete graphics (!) but it’s too expensive and also too bulky for (my) everyday use.
Computer software
On both desktop and laptop, I use almost
entirely free and open-source (FOSS)
software, with some notable exceptions for GPU computing (CUDA
libraries) and gaming (Steam client)—and whatever
closed source firmware and blobs are unfortunately required to run
modern hardware.
Operating system
I use a GNU/Linux operating system that is configured and built declaratively using Nix, an implementation of a purely functional software deployment model.
- kernel: latest stable Linux kernel
- userland: GNU core utilities
- bootloader: systemd-boot, though I hope to enable secure boot using lanzaboote or limine at some point
- service manager: systemd, which orchestrates the start-up of system services using declarative configuration
- filesystem: btrfs, a modern copy-on-write filesystem, declaratively configured via disko (though I’m keeping an eye on bcachefs development)
- distribution: NixOS, an operating
system declaratively configured and built using Nix, with flakes enabled, using the
unstable(rolling) release channel- package manager: Lix, a community-driven implementation of Nix, though I’m curious about snix (a work-in-progress Nix implementation)
- user environment: Home Manager, which manages the declarative installation and configuration of my user-facing software
- Nix CLI helper: nh, which provides a sensible command-line interface for various Nix operations
- opt-in state: impermanence, which allows only selected files/directories to persist on disk across reboots, keeping the system ~immutable (maintaining the “new computer smell”)
- secret management: sops-nix, based on SOPS, using age encryption
Previously, I used Debian and Arch Linux—configured with an ad-hoc combination of shell scripts and Ansible playbooks—before the allure of declarative configuration drew me to NixOS.
Perhaps I might try using Guix—a declarative package manager and GNU/Linux distribution inspired by Nix—in the future. I’ve also heard great things about FreeBSD and experimental operating systems like RedoxOS and Haiku, but have no plans to try them unless they achieve feature parity with NixOS in terms of system configuration.
Networking
My basic networking stack is pretty standard, though a notable
omission is NetworkManager—I find it
unnecessary when iwd exists, even for portable
computers.
- network manager: systemd-networkd
- DNS resolver: systemd-resolved, though I hope to self-host an authoritative/recursive/?? nameserver using Hickory DNS
- wireless networking: iwd, with the iwgtk frontend
- firewall: nftables
- mesh VPN: Tailscale free tier, though I hope to migrate to a self-hosted Headscale control plane or Netbird
- secure shell (SSH): OpenSSH client and server
- traffic analyzer: Wireshark
I still know very little about networking, perhaps just enough to hurt myself. I’ve read through this excellent primer to how the Internet works and am slowly working through Computer Networks: A Systems Approach. I want to understand enough about DNS, (reverse) proxies, firewalls, and (mesh) VPNs—and how they interact with containers and VMs—to confidently configure my network without fear of compromising it.
(I also don’t like “networking” in general—I prefer “making friends”.)
Command-line tools
I spend a decent amount of time interacting with the command line, so I use modern CLI tools to make the experience comfortable and productive.
- terminal emulator: Wezterm and Ghostty, previously Kitty
- terminal multiplexer: zellij
- shell: fish, though I am nushell- and elvish-curious
- autopair
- grc
- colored-man-pages
- shell prompt: starship
- shell history: atuin
- file manager: nnn
- text editor: Neovim, though I am Helix-curious
- miscellaneous tools with great UI/UX:
- navigate filesystem (
cdalternative): zoxide - print files (
catalternative): bat - list files (
lsalternative): eza - find files (
findalternative): fd - search file contents (
grepalternative): ripgrep and ripgrep-all - wrangle text (
cutandawkalternative): choose - fuzzy finder: fzf, though skim seems interesting too
- file compression/extraction (
zip,tar, etc. alternative): ouch - filesystem space manager (
dualternative): dua and dust - system monitor (
topalternative): bottom
- navigate filesystem (
Desktop environment
I use a minimalistic desktop environment that is largely keyboard-driven:
- Wayland compositor: niri (a scrolling window manager) with integrated xwayland-satellite providing rootless Xwayland integration and the Gnome XDG desktop portal providing screen-sharing support
- launcher: fuzzel
- clipboard manager: CopyQ
- notifications: dunst
- wallpaper manager: awww, with the waypaper frontend
- styling: Stylix
(Previously, I used Qtile—an excellent tiling window manager written and configured in Python—but occasional screen-sharing bugs kept biting me, and I decided to switch to Niri.)
Web browser
My browser of choice is Firefox, though I’ve previously used qutebrowser and hope to use Servo in the future. Firefox is augmented with several plugins for privacy and convenience:
- uBlock Origin, an ad-blocker
- ClearURLs, which removes tracking elements from URLs
- Temporary Containers Plus, which sandboxes websites in isolated temporary containers
- LibRedirect, which redirects user-hostile websites to alternative privacy-friendly frontends
- User-Agent Switcher and Manager, which allows you to spoof your user agent
- Violentmonkey, a userscript manager
- Vimium, which provides Vim keybindings for Firefox, making it more keyboard-driven
- DarkReader, which provides automatic dark mode for websites
- Bitwarden, a browser extension for the Bitwarden password manager
- Readeck, a browser extension for the Readeck bookmark manager
- Zotero Connector, a browser extension for the Zotero reference manager
Multimedia
My multimedia backend is pipewire with wireplumber, supporting ALSA, PulseAudio and JACK APIs; I have almost no idea what all these are and what they do, but everything I need seems to work.
I use several standard multimedia applications, listed here from most- to least-frequently used:
- media player: mpv, with several plugins (modernz, thumbfast, sponsorblock-minimal, visualizer, webtorrent-mpv-hook)
- image viewer: imv
- photo management: Digikam
- vector editing: Inkscape, though I am curious about Graphite
- diagrams: draw.io
- raster editing: GIMP, and more recently, Krita
I rarely—if ever—edit audio/video or screencast or work with 3D graphics, but I keep these amazing programs installed anyway on the off chance that I’ll need them:
- audio editing: Audacity
- video editing: Kdenlive and Shotcut
- screencasting: OBS Studio
- 3D modeling: Blender
Productivity software
- mail client: Thunderbird
- PDF reader: sioyek, Okular
- office software: LibreOffice, OnlyOffice
- reference manager: Zotero, with a self-hosted WebDAV server for file storage and syncing
- plain text accounting: Beancount, a system for double-entry bookkeepping with the Fava web interface
Homelab services
TODO
Software development
Scientists are not software engineers, and the code we write certainly shows it.
But writing good code is important: creating a well-documented,
reproducible computational pipeline from raw data to research
outputs is—in my opinion—the foundation of high-quality science. During
my PhD, I happened upon The Good
Research Code Handbook, which inspired me to hone my axe
software development skills.
“Give me six hours to chop down a tree and I will spend the first four sharpening the axe.”
— not Abraham Lincoln
Integrated Development Environment (IDEs)
My primary GUI text editor is VSCodium (a FOSS-licensed build of Visual Studio Code), which also doubles as an IDE with the following plugins (sourced from the Open VSX Registry, a FOSS extension marketplace integrated into NixOS via nix-vscode-extensions):
- TODO VSCodium plugins
I’m also interested in trying out the Zed editor.
Version control
git is my distributed version control system of choice, though I use it poorly—mostly as a crude versioning + backup + sync tool. As I mostly work on solo projects, this hasn’t been a hindrance, but I should really learn to use it better.
I’m also hoping to learn to use jujutsu, which can apparently be
effectively used in parallel with an existing git
repository.
Environment management
Nix with nix-direnv
I want to use Nix to automate pre-commit hooks and also set up self-hosted CI for my projects
Python ecosystem
As a scientist, I program almost entirely in Python, a language acclaimed for its simple design, incredible ecosystem and ease-of-use, but reviled for its hodgepodge of unstandardized tooling.
Modern Python tools, however, have broken this curse—and I think the glory days are here to stay:
- uv installs (and builds) Python packages and manages Python environments—it’s incredibly fast and uses a lockfile (finally!);
- ruff lints and auto-formats my code (and is integrated into my editor!);
- ty provides static analysis
using Python type hints (and
is which is also integrated into my editor!) [Note:
tyis still in beta]
Python standard library
Parts of the Python standard library are amazing and incredibly well-designed. The following standard library modules are ones I use often or am familiar with:
- functional programming modules
itertoolsis amazing: I’m a huge fan of all the combinatoric iterators (Cartesian product, permutations, combinations with and without replacement) as well as those for batching and chaining.pairwiseandstarmaphave also been very useful.functoolscontains utilities for partial function application (partial,partialmethod), caching function outputs (cache,cached_property,lru_cache), repeated function application (reduce), and decorator creation (wraps).
- useful Python constructs
contextlibhelps create context managers.collectionsprovides container datatypes—some of my favorites arenamedtuple,Counter, anddefaultdict.dataclassesreduces repetitive boilerplate in the__init__method when creating classes that are primarily intended to store data.copy.deepcopyprevents me from unintentionally modifying nested mutable objects, which has led to many annoying bugs over the years.
- interacting with the operating system and other installed programs
osprovides rather low-level operating system interfaces that are often unnecessary: I often prefer using high-level interfaces provided by other modules instead.subprocesslets me run external commands from Python.
- filesystem operations
pathlibprovides object-oriented filesystem paths, and is the modern Pythonic interface to the filesystem: stop usingos.path!shutil.rmtreeis unfortunately the only way to delete an entire directory tree; this isn’t supported inpathlib, for some reason.tempfileis great for securely creating temporary files and directories.
- handling various file formats
compressioncontains useful compression utilities, as dotarfileandzipfile.jsonis great for parsing and writing JSON.pickleis the standard Python serialization tool, but I prefer to use more stable output file formats whenever possible to ensure compatibility across different versions.structcontains utilities to pack/unpack binary data in the form of C structs—I recently used this to create a parser for some proprietary neural recording data formats.
- controlling how Python uses system resources
multiprocessingallows for process-based parallelism, where operations can be parallelized across different CPU cores. Python has historically had a Global Interpreter Lock that prevents thread-based parallelism to avoid issues with concurrency; however, modern Python versions have support for free threading that should make parallel processing better, but this isn’t fully supported by the ecosystem yet.gcinterfaces with the garbage collector—sometimes manually triggering a cleanup helps me manage memory effectively.
- string handling
reprovides support for regular expressions, which scare me but not my linguist friends.stringprovides some useful constants including ASCII characters, hexadecimal and octal digits, punctuation, and whitespace.string.templatelib—I am very curious about Template String Literals (t-strings), something that would have been handy a few years ago when I was writing a caching library.
- meta-utilities related to Python code
importlib—I useimportlib.util.find_specto dynamically check if packages are installed andimportlib.resources.filesto read non-code files distributed along with packages (e.g. data files).inspect—I’ve used this module (in a rather cursed way) to introspect function arguments to automatically name files produced by those functions.runpylets me run Python files and access the variables in that namespace—this is handy when I use Python files to store information that should not be included in (and thus, should not be importable from) my Python project package.
- other miscellaneous utilities
datetimehandles datetimes, which is an accursed branch of programming not meant for mortal eyes.hashlibimplements several hashing algorithms.
Alternatives to the standard library
Several parts of the standard library are annoying to use, with poor UX—often involving tons of boilerplate—so some excellent third-party libraries have filled the gap:
- Loguru (a
loggingalternative) provides simplified logging with great defaults. - Click (an
argparsealternative) makes creating CLIs very simple, using composable decorators. - Requests (a
urllibalternative) is a simple HTTP library. - python-dotenv
automatically sets environment variables from
.envfiles, without needing to manipulateos.environmanually. - xdg-base-dirs computes the paths to directories specified by the XDG Base Directory Specification, reducing boilerplate code in libraries that I create.
- pytest (a
unittestalternative) is a testing framework that I should really be using more often to write automated tests for my libraries. - Sphinx (a
pydocalternative) is an extensible Python documentation generator used widely in the ecosystem. I like the numpydoc style for docstrings; the reStructuredText style is too ugly to my eye. - line_profiler provides line-by-line profiling for Python code, unlike the standard library’s profilers, which only provide function-level resolution.
- memray is a memory profiler for Python that I haven’t used, but seems interesting.
Basic scientific computing
The ubiquity of Python in the sciences comes down to the incredible scientific computing ecosystem:
- NumPy creates and manipulates multidimensional arrays.
- pandas and Polars are compatible dataframe libraries that handle tabular data.
- SciPy provides fundamental algorithms for scientific computing.
- Xarray annotates multidimensional arrays with labels and other metadata.
- Pint supports unit-aware scientific computing.
High-performance numerical computing
Much science depends on high-performance numerical computing, which often takes advantage of parallel processing using GPUs and TPUs. Thankfully, the array API standard ensures compatibility across a variety of scientific computing libraries:
- Numba is a JIT compiler that turns Python and NumPy code into optimized machine code.
- CuPy provides GPU-acclerated array computing compatible with NumPy and SciPy, using the proprietary CUDA Toolkit backend libraries.
- PyTorch provides GPU-acclerated array computing and automatic differentiation.
- JAX also provides GPU-accelerated array computing and automatic differentiation with JIT compilation and a focus on pure functions.
- Optimized Einsum provides optimized backend implementations for Einstein Summation, a commonly used tool to simplify complicated expressions in linear algebra.
Visualization libraries
Python also has several excellent visualization libraries that produce high-quality figures:
- Matplotlib is the standard toolkit to create visualizations, inspired by MATLAB graphics commands.
- seaborn is a data visualization library based on Matplotlib that uses a ggplot2-style Grammar of Graphics approach.
- Pillow provides image processing capabilities.
- mpld3 exports Matplotlib figures to the web using the D3js JavaScript library.
- PyVista is a Pythonic interface to the C++ Visualization Toolkit (VTK) which provides tools for 3D visualization.
- K3D-jupyter supports interactive 3D visualization in notebooks.
- Plotly creates interactive
data visualizations using a
seaborn-style API that can be exported to the web using the Plotly.js JavaScript library. - skunk supports inserting SVGs into Matplotlib elements (something that comes in handy when annotating figures for scientific publication).
- CairoSVG supports converting SVGs to PDFs and other formats (again, something useful for scientific publishing).
- tqdm creates progress bars to track loop iterations.
Interactive computing
Interactive computing is an integral part of scientific data analysis: being able to iterate rapidly over data and visualize the results in a single unified interface is very handy.
- IPython is an interactive Python shell.
- ipykernel is the IPython kernel that’s used as the Python backend in Jupyter Notebooks.
- ipympl enables interactive Matplotlib features when used in a notebook environment.
- Jupyter Widgets provide interactive controls within notebook environments.
- jupytext
interconverts Jupyter notebooks and plain text files (e.g. encoded in
the
py:percentformat) to make version control easier.
Data science
As a computational vision scientist, I analyze data and build computational models using a combination of machine learning, deep learning, and traditional statistics, all of which have great Python libraries:
- scikit-learn implements standard machine learning algorithms for classification, regression and clustering.
- scikit-image provides various image processing algorithms.
- PyTorch, in addition to GPU-accelerated computing, also provides tools to develop, train, and run inference on deep neural network models, supported by domain-specific libraries such as torchvision and torchaudio.
- PyTorch Lightning is a high-level PyTorch wrapper that simplifies model training and inference pipelines.
- TensorBoard is a visualization toolkit developed for TensorFlow (but compatible with PyTorch) that supports tracking metrics during model training.
- Flax is a neural network library built on JAX (I haven’t used it yet, but I’m curious).
- Transformers provides a high-level API for various transformer models.
- timm provides a collection of computer vision models.
- statsmodels provides tools for advanced statistical analyses (though I’ve never had to use them).
Cognitive neuroscience
As a cognitive neuroscientist, I also use several excellent domain-specific Python libraries and non-Python tools:
- magnetic resonance imaging (MRI)
- NiBabel supports reading/writing various neuroimaging file formats.
- dcm2niix converts raw DICOM images from medical scanners to the NIfTI format.
- HeuDiConv uses heuristics to convert and organize raw neuroimaging data according to the Brain Imaging Data Structure (BIDS) standard.
- Nilearn provides tools to explore, visualize, and analyze volumetric and surface-based brain data.
- fMRIPrep is a robust standardized preprocessing pipeline for fMRI data.
- sMRIPrep is a similar preprocessing pipeline for structural MRI data.
- FreeSurfer is a toolkit for processing human neuroimaging data, but I’ve never used it directly—only wrapped by some high-level workflows like fMRIPrep.
- DIPY is an imaging library for diffusion imaging—though I don’t use this experimental method, the computational tools in this library are useful.
- reorient is a simple web-based tool to reorient MRI data—something that’s often necessary for manual alignment (e.g. AC-PC alignment)
- human neurophysiology (EEG, sEEG, MEG, ECoG, etc.)
- MNE-Python provides tools to explore, visualize and analyze human neurophysiological data.
- MNE-BIDS helps organize human neurophysiological data according to the Brain Imaging Data Structure (BIDS) specification.
- behavioral experiments
- PsychoPy (and its online counterpart, PsychoJS) is used to create computer-driven behavioral experiments and optionally run them in a web browser.
- jsPsych is a JavaScript framework also used to create behavioral experiments that run in a web browser.
- Psychophysics Toolbox (PTB) is a GNU Octave/MATLAB toolkit also used to create behavioral experiments.
Smartphones
Hardware
I use a Google Pixel 8 smartphone running GrapheneOS, a security- and privacy-focused Android-based operating system. The phone itself is safely ensconced in a bulky OtterBox case that has already protected it from dozens of gravity-induced collisions with a wide variety of solid surfaces, and will hopefully keep up its valiant efforts in the future.
I also have a Samsung Galaxy M31 purchased in India that is currently running an unofficial build of LineageOS 22. I’ve stopped using it because it doesn’t support cellular bands in the US, but I’d like to repurpose it and put its compute to good use—as a cheap web server, perhaps?
Software
On both phones, in the spirit of using only free privacy-respecting software, Google Play services are not installed—and no free alternatives such as MicroG are used either. This prevents several proprietary applications from working on my phone—and thus nothing of value is lost 😉.
App stores
F-Droid and IzzyOnDroid are the primary application repositories where I find free and open source software. On occasion, I use Obtainium to download app releases directly from their authors. Some default software is also provided directly from GrapheneOS’ AppStore. To download the few non-free apps that I am forced to use, I use Aurora Store, a privacy-preserving frontend to the Google Play Store, where most Android applications are published.
TODO phone apps
Other computing devices
Smartwatch
Pinetime running InfiniTime firmware, though I’m curious about WASP-OS
e-reader
I have a Kindle PaperWhite 4 (2018) with 8 GB storage, wireless connectivity through WiFi, and a backlight, which I purchased in India.
Of course, I followed rather poorly formatted instructions in a thread on a shady forum for e-readers to jailbreak the device: this worked! Then, I installed KOReader and a variety of plugins for the e-reader. Now all that’s left is to start using it! 🙃
Microcontrollers
I have an 8 GB Raspberry Pi 4 gathering dust, as well as several ESP8266 NodeMCU 12-E boards that are awaiting decent projects.
Hosted services
Domain name registrar
I use Namecheap as my domain
name registrar for raj-magesh.org—I purchased the domain
for ~10 years. Namecheap has been fine and has decent customer
service—they provided me with API access despite not meeting their
minimum purchase criterion.
If I needed a new domain, I would probably switch to Njalla—a privacy-respecting registrar that
supports anonymous payments through cryptocurrency. However, Njalla would be the actual registrant
of the domain, though they claim that supreme
executive power full control would be provided to their
customers.
Wireguard VPN
I’ve been using Mullvad VPN for ~2 years now.
I’m satisfied with their
- advocacy for consumer privacy,
- fair pricing model (a flat rate of 5 EUR/month),
- support for anonymous payments (cryptocurrency or gift cards),
- quality of service, with access to uncongested servers in various countries without any bandwidth restrictions, and their
- technical contributions to the zero-trust VPN space (discussed extensively in their blog posts).
I wish they would
- revert their decision to disable port forwarding, though I’m sympathetic to their concerns, and
- start providing servers in India, as I’m sometimes forced to use geo-locked government/banking services hosted there.
I hope to use my Mullvad account as an exit node for Tailscale. This isn’t currently supported: one has to purchase a Mullvad VPN plan via Tailscale—forgoing anonymous payments—to avail this feature. Luckily, there appears to be a work-in-progress pull request providing this feature in Headscale, a self-hosted control plane for a Tailscale network.
I’ve been using Fastmail as
my email provider for the past couple of years. All email directed to
raj-magesh.org and its subdomains get forwarded to my
personal email account there.
I’m satisfied with their
- email server, which hasn’t had any downtime that I’ve noticed,
- webmail client, which has a simple, clean interface (though I barely use it), and their
- numerous contributions to modern email standards, including the JMAP protocol.
I have no specific complaints about Fastmail’s service, but wish the email ecosystem as a whole would support:
- standard IMAP/SMTP instead of whatever godforsaken Exchange protocol Microsoft uses for its mail servers—the sysadmins at Johns Hopkins prevent me from using third-party mail clients with my Microsoft account (shame on them!), forcing me to use the Owl plugin for Thunderbird and DavMail Gateway to translate from Exchange to standard protocols (though I’ve never successfully gotten the latter to work)
- end-to-end email encryption by default, though I understand this is technically complicated and not standardized (ProtonMail and Tuta Mail provide bespoke implementations, but they aren’t supported by standard mail clients)
- receiving email from any domain and smaller mail providers instead of only allowlisting the largest big-tech providers (I was burnt by this when VFS Global wouldn’t receive emails from my personal domain, forcing me to maintain a personal Outlook account for compatibility with archaic businesses)
I am currently forced to use Outlook and Gmail accounts for work. As a silver lining, the University of Pittsburgh and Carnegie Mellon University both support using Thunderbird on the desktop—though for some reason not on Android.
Messaging
My Matrix account @raj-magesh:matrix.org
is hosted on the matrix.org
homeserver, though I hope to self-host my own homeserver using Continuwuity, a community-driven
Matrix server implementation.
On both the web and Android, I use the Matrix clients provided by Element. They are still finicky—especially during key verification—but generally suffice for basic communication. Matrix is not yet as full-featured as WhatsApp or Telegram or Signal, but it is gradually improving and I hope it will eventually reach feature parity with the closed-source messaging platforms.
Microblogging
I created a profile on Bluesky to advertise my research in neuroscience. While I was reluctant to dip my toes into the cesspool of social media, the community of scientists I follow is generally very pleasant and I often find interesting discussions and literature on the platform.
Bluesky is open-source, permissively licensed, and is based on the AT protocol, which supports decentralized networking. At the same time, the existing platform is largely monopolized by a single entity, and I am wary of enshittification. At some point soon™, I’ll start self-hosting Fediverse services and use the POSSE approach to Publish On my own site, and Syndicate Elsewhere.
Software forge
I use Codeberg, a Forgejo-based git forge operated by a community-driven non-profit association focused on hosting free and open-source (FOSS) software. All my personal projects are hosted on Codeberg!
Additionally, I use Codeberg Pages (an instance of git-pages) to host my personal website (where you’re likely reading this!)
Unfortunately, most open-source development still occurs on GitHub, which is now owned by Microsoft and is becoming increasingly user-hostile. I maintain a GitHub account to contribute to software hosted there, but urge maintainers to consider switching to free alternatives such as Codeberg, SourceHut, or even Radicle—git is a distributed version control system, after all.
Miscellaneous items
- Iron Flask wide mouth 40 oz water bottle
- weighted blanket
- Geekey multitool keychain
- FlexiSpot E7 standing desk
- Aeron Chair by Herman Miller
- Hakko FX-888D soldering station
- Coop Original Adjustable Pillow
- Instant Pot
- Intex 67765ED air mattresses
- NUTS U.S. Wasabi Green Peas
- Philips Norelco Shaver 3800
- LIFX Color PAR38 Smart LED Bulb 1600 Lumen
- Kenmore 600 Series bagged canister vacuum
- Lavatools PT12 digital meat thermometer
- Osprey Comet laptop backpack
- JAKEMY precision screwdriver 73-in-1 kit S2 steel long bits
Fonts
- monospace
- sans-serif
- serif
- handwriting
- emoji
- OpenMoji Color (the fonts themselves)
- fallback