]]>]]>You can tap straight to a song, listen with the screen off, and use Android’s playback controls. You don’t have to wind a real tape back to the beginning or rescue it with a pencil. I wanted the retro feel, not every inconvenience that came with it.
A cassette tape sitting in a player had become one of the tests I’d give new models. Could they make something that felt like a real object, rather than just a rectangle with two circles in it?
Fable was the first to do a good enough job with the cassette player and tape design that I actually wanted to use the result. That was the spark for Mixtape. What had been a recurring model test started turning into something I wanted to listen to music with.
The design grew through an HTML and SVG component demo, then became a native Android interface. Keeping the tape, deck, sticker, case and paper insert separate meant they could each have their own character.
Once there was a player I liked, other memories started finding their way in. One was the little sets of three songs by an artist that I’d hear on the radio. Mixtape can group an artist’s tracks into those three-song sets and spread them across tapes: enough time to settle into an artist before moving on to someone else. There are other grouping options too, and a choice of how many songs go on each tape.
The library itself looks back to stacks of cassette cases. When nothing is playing, you get a page of spines to browse, rather than a player waiting over an empty track list. Pick a tape and its player and sleeve open together.
The last button on the deck does two jobs: tap the double-arrow/gear button to toggle between the track list and the mixtape list; long-press that same button to open Settings. On the opening tape stack, the corner gear takes you straight there.
In landscape, the full-page collection becomes two columns. It is still a stack of tapes, just making sensible use of a different-shaped screen.
I wanted the track list to feel like the back of a cassette sleeve, not a conventional playlist dropped underneath a decorative player. The spine and back use the same paper design, and both sit behind the same case tint and plastic finish.
There are plain and lined papers, album-style inserts, clear and coloured cases, and tapes with clear or opaque shells. Reflections vary a little between cases so the stack doesn’t look mechanically identical. The open-fronted decks leave the cassette and its moving reels in view, with chunky transport buttons you can actually use.
The modern conveniences are still there. Turn the phone sideways and the player and sleeve sit alongside each other. Long track names can run off to the right; drag the list sideways when you want to read the rest.
For a bit of pruning, long-press a track name to open its menu. Remove from mixtape keeps the music file on your phone; Delete from device asks you to confirm before deleting the file itself.
On the Walkmans I used, I’d mash Play and Fast Forward together to hear the tape rushing past the heads. I’d listen for the breaks between tracks, trying to land on that great song somewhere in the middle of a mixtape. It was a very particular way of knowing your music.
I liked that half-recognisable rush enough to include it by default in Mixtape. Fast-forward and rewind use snippets of the actual tracks, with a spin-up, a quick journey through the music, and a spin-down near the destination. Longer jumps take a little longer, up to a cap, rather than squeezing a whole album into an impossible squeak. The winding audio is a little quieter than normal playback.
There is no two-button squeeze required this time. And if you’d rather skip the nostalgia, Fast-forward / rewind sound can be switched off in Settings → Mixtapes → Playback.
Then there are the little imperfections. You start writing a title with a texta, confident it will fit, and discover halfway through that your plan was optimistic. Some Mixtape titles do the same thing: they reach the end of the paper and get cut off, rather than politely turning into an ellipsis.
The small hand-drawn symbols matter too. A star, a music note, a little swirl in a different colour; not always in quite the same place. A few sleeves even have those tiny boxed letters or numbers. They help a collection feel like individual tapes somebody has handled and labelled.
To make a tape your own, long-press its spine in the collection to configure its name and appearance. There is also a dice button for trying a fresh combination, with the changes kept in the editor until you Save.
There are a few things I’d like to explore next:
Those are future plans, not features to hunt for in the current app.
Mixtape runs on Android 7 or later. The source code is on GitHub if you’d like to look under the plastic or follow along.
For now, put a tape on. No pencil required.
]]>org.puzzleduck.mixtape.
Mixtape is developed by PuZZleDucK. Privacy questions can be sent to PuZZleDucK+mixtape@gmail.com.
Mixtape plays music stored on your device. It has no user account, advertising SDK, developer-operated analytics service or automatic upload of your music library. The app does not request Android’s internet permission.
The app does access and store some information locally to work. Android media controls and Android-managed backups are separate data flows described below. “No upload to us” does not mean “no data is processed” or “nothing can leave the device”.
With your permission, Mixtape reads Android’s audio library and opens audio files for playback. It uses track titles, artist and album names, filenames, durations, file types and sizes, track numbers, media identifiers and added/modified dates to organise tapes, display track information and play your music.
Fast-forward and rewind effects decode short portions of those same files locally. They do not record the microphone or upload audio for processing.
You can deny or revoke audio access in Android’s app-permission settings. Library access and playback of inaccessible files will then be unavailable. Revoking a permission does not itself erase the app’s saved tape settings.
The app also uses Android’s media-playback service and wake-lock facilities for background playback. Its playback dependencies declare network-state access; this is not permission to send music or other information over the internet.
Mixtape stores app-private preferences for permission-request history, tape names and appearance, handwriting and theme choices, library grouping, filename exclusions, and tape membership. Membership includes media identifiers and identifiers of songs removed from tapes, so a library refresh does not silently add them back.
The app reads audio from its existing location. Creating or editing a virtual tape does not create a new copy of each music file.
Mixtape uses Android’s app-private storage protections for its preferences. This is not a promise of protection against someone who has access to an unlocked, rooted or otherwise compromised device.
Track metadata, the playback queue and playback state are made available through Android’s media-session interface. This enables notifications, lock-screen controls and headset or Bluetooth media controls. Mixtape does not provide an Android Auto or Automotive browsing interface.
Those surfaces may show song titles, artists and other media information outside Mixtape’s own screen. Their operation and any further processing are controlled by Android and the connected host or service, not a Mixtape server.
Mixtape allows Android backup of its saved preferences. Depending on your device and backup settings, Android or your backup provider may copy and later restore that data, including during a device transfer.
These are system-managed copies, not uploads to a server operated by PuZZleDucK. Uninstalling the app does not guarantee removal of an existing backup. See your device’s backup controls and Android’s backup documentation.
If you contact PuZZleDucK, the email address, message and any attachments you choose to send are received through the email provider. They are separate from the app’s local-only operation. Please avoid including unnecessary personal information.
External websites, app stores, email providers and connected platform services have their own privacy policies. This statement describes Mixtape itself; it does not make promises on their behalf.
We will update this policy when the way Mixtape handles data changes. Questions or requests about information you have voluntarily sent can be directed to PuZZleDucK+mixtape@gmail.com.
]]>Orbitals started with a fairly modest ambition. Make some dots move around the screen in an interesting way. Touch the screen, disturb the pattern, and watch it settle into something else.
Fourteen years later, the dots still appeal to me. The Android project around them needed rather more attention.
This September I’ve been revisiting Orbitals with help from Codex. The work has been about getting an old app building and behaving on current Android, without throwing away the little mathematical toy that made it worth writing in the first place.
Real Android 16 emulator captures from the revived Orbital_LWP app. These are enlarged crops, not concept art. The full screenshots below show the original, much smaller dot scale.
The trail starts with Target Live Wallpaper. In February 2012, I was writing about fireworks, custom models and the usual collection of unfinished Android experiments. Near the bottom of that post was a small addition: “Also just added ‘orbitals’”.
By 3 May 2012, it had become a separate release. I described Orbitals as the second spin-off from Target Live Wallpaper.
The inspirations were quite specific. Windows 8’s loading bubbles suggested the chasing dots. Ordinary orbits supplied the simpler patterns, and the trefoil knot inspired the knotted ones. Ubuntu, XDA and Slashdot were among the references for the tech and open-source colour schemes.
There was no astronomy simulation hiding underneath. This was an excuse to play with motion, colour and a few equations. In the original release, touching the screen changed the randomised colour scheme, trail length and speed.
In August 2012, I wrote about fixing some “shifty maths” and separating the transition away from an orbit from the transition back. That let the dots make interesting patterns between the settled ones. The movement between shapes was becoming part of the fun.
There are two related repositories in this story. Orbital-Live-Wallpaper holds the original 2012 app. Orbital_LWP has its own Android package identity and a later Android Studio history, including settings fixes from 2015.
Both received modernisation work on 22 September 2026. They are related, but they are not interchangeable builds. The screenshots in this post show Orbital_LWP, which retains six orbital patterns, nine palettes and its red-arc widget.
Getting a successful build was the first job. Both projects now target Android 16, API 36, with modern Gradle tooling, Java 17 source compatibility and AndroidX. But a fresh build alone would have left plenty of old assumptions intact.
A live wallpaper can have more than one engine. Android may be showing a preview while another instance is active. Each engine now owns its animation state, rather than letting a preview interfere with another instance. Animation callbacks stop when the wallpaper is hidden or its surface disappears, and listeners are removed when the engine is destroyed.
Settings also needed to do what they said. In the original app, placeholder switches became working touch-follow and orbit-transition controls. In Orbital_LWP, the work repaired ignored direction and transition-speed settings, preference loading on a cold start, and mismatched colour labels. Existing preference keys and palette values were preserved.
The surrounding screens received day and night themes and system-bar insets. Widget configuration now starts from cancellation, so backing out does not accidentally create a widget. The widgets remain static; there is no reason to keep waking up a background task to redraw an unchanging image.
That is the useful part of this Codex-assisted return for me. It made it practical to revisit the build, lifecycle code and tests around an old experiment, while keeping the original orbit formulas and visual character.
The original app’s revival records five passing instrumentation tests on an Android 16 phone, plus manual preview, touch and settings checks. Orbital_LWP records six Android 16 instrumentation tests, five JVM tests and seven compatibility contracts containing 48 assertions. A separate review reran the local contracts, unit tests and lint, and inspected the saved device evidence.
Those checks matter more than a claim that the app is simply “modern”. They cover things such as settings surviving recreation, real wallpaper-engine callbacks, and widget configuration behaving properly.
They do not establish long-term battery performance or compatibility with every Android release. Android 6 runtime support remains untested. The original dot sizing and low-resolution static widget artwork also remain visible reminders of the app’s age. The revival is working development code, not a claim that a new store release has shipped.
No accounts, advertising or usage analytics. The two development builds described here do not include a service that collects wallpaper-user data for PuZZleDucK, and neither requests internet access. They do not send us personal information, advertising identifiers, location or a history of your touches.
Touch input drives the animation while you use it. It is not kept as an interaction history.
The apps do save configuration on your device, such as your chosen pattern, colours and speed. Those settings are still data: they let the wallpaper remember how you set it up, but they are not tracking records and we do not receive them.
There is no developer-operated database of wallpaper users to retain, sell or share. Local settings normally remain until you clear the app’s storage or uninstall it. Both current builds allow Android backup, so your device or backup provider may preserve and restore settings. Uninstalling does not promise deletion of an Android-managed backup; use your device’s backup controls for those copies. Android’s backup documentation explains this separate system behaviour.
This statement covers the September 2026 development versions discussed here: Orbital Live Wallpaper 2.1 (orbitlivewallpaperfree.puzzleduck.com) and Orbital_LWP 2.0 (org.puzzleduck.orbital_lwp). If you follow an external link, the browser, app store or other service has its own privacy policy.
For questions, email PuZZleDucK. Any message you choose to send is separate from the apps’ operation and is handled through the email service.
The appeal is still the same as it was in 2012. A few coloured dots follow a pattern, a touch sends them somewhere else, and the screen becomes a small experiment in motion again.
It is good to have the code moving too.
]]>To configure Kama we need to add PhantomJS and the PhantomJS launcher, adjust karma.conf.js and enable the es6 polyfills in src/polyfills.ts.
For e2e testing we need to configure protractor to run the tests in a headless browser in protractor.conf.js. Then we can make a few small changes to a standard .gitlab-ci.yml and we are ready to run ng e2e tests in GitLab CI.
To start our project we run:
ng new GitLab-Angular-e2e-CI
cd GitLab-Angular-e2e-CI/
now running the tests we find that Karma and Protractor both launch chrome browsers to run the tests.
ng test --single-run
ng e2e
Lets install the dependencies and plugins to let Karma run without a browser window:
"devDependencies": {
...
"karma-phantomjs-launcher": "^1.0.4",
"phantomjs-prebuilt": "^2.1.16",
...
plugins: [
...
require('karma-phantomjs-launcher'),
...
browsers: ['Chrome', 'PhantomJS'],
import 'core-js/es6/symbol';
import 'core-js/es6/object';
import 'core-js/es6/function';
import 'core-js/es6/parse-int';
import 'core-js/es6/parse-float';
import 'core-js/es6/number';
import 'core-js/es6/math';
import 'core-js/es6/string';
import 'core-js/es6/date';
import 'core-js/es6/array';
import 'core-js/es6/regexp';
import 'core-js/es6/map';
import 'core-js/es6/weak-map';
import 'core-js/es6/set';
After updating npm our unit tests are ready for CI and can run headless with the command:
npm install
ng test --single-run --browser PhantomJS
Now we’ll’ enable Protractor to do the same:
Modify the protractor capabilities to target a headless chrome browser. This has the added benefit of running without popping up a browser when running ng e2e locally during development.
capabilities: {
browserName: 'chrome',
chromeOptions: {
args: ["--no-sandbox", "--headless", "--disable-gpu", "--window-size=800,600" ]
}
},
Add the test_e2e_with_lab job to your CI pipeline to run in parallel with the regular angular test test suite. While the rest of the build and test process will happen on the node:latest docker image, the test_e2e_with_lab job will run on the trion/ng-cli-e2e image as it was the docker image with the most pre-installed dependencies for the basic e2e setup with a global install of protractor required to push it over the edge (despite protractor already being in the projects dev dependencies).
variables:
DEPENDENCY_PATH: "./node_modules"
NG_CLI_PATH: "./node_modules/@angular/cli/bin/ng"
image: node:latest
cache:
paths:
- node_modules/
stages:
- install_dependencies
- test
install_dependencies:
stage: install_dependencies
script:
- npm install --quiet
artifacts:
paths:
- $DEPENDENCY_PATH
test_with_lab:
stage: test
script: $NG_CLI_PATH test --browser PhantomJS --single-run --progress=false
test_e2e_with_lab:
image: trion/ng-cli-e2e
stage: test
script:
- npm rebuild node-sass --force
- npm install -g protractor
- $NG_CLI_PATH e2e --progress=false
Now your project should be running ng test and ng e2e test suites on every push to master and on every branch pushed for review.
You can checkout a minimal example at GitLab-Angular-e2e-CI
Next time we’ll look at adding coverage reporting and vulnerability code analysis.
]]>It happened that I’d just turned up to the first FOSS hack night at YBF Teamsquare when this tragedy unfolded and I was able to borrow a Kali Linux boot usb from someone at the meetup to boot up the laptop and confirm the hardware was still all functional. Memory was ok, I could read the drive fine, and almost everything seemed to be the there… except in the boot directory only the memtest86 images were present… What happened to my kernel images :o
Spoiler alert: I never figured out why they dissapeared, but there is a very Linuxey happy ending to it all. A few people at the hack night pointed me in the direction of chroot-ing into the disk and repairing the system in place. It took a few tries to get everything to work, but for future reference the process was as follows:
From the live-system open a terminal and run the following:
umount /dev/mmcblk1p1 # unmount the automounted drive before starting
cd /mnt
sudo mkdir duck # create a working directory to use
sudo mount /dev/mmcblk1p1 /mnt/duck # mount the disk in our temp directory
sudo mount -t proc none /mnt/duck/proc # mount system directories for chroot
sudo mount -o bind /dev /mnt/duck/dev
sudo mount -o bind /run /mnt/duck/run
sudo mount -o bind /sys /mnt/duck/sys
sudo chroot /mnt/duck /bin/bash
Now we are running the non-booting-system with its devices, processes and system. We can now run commands to repair the system:
apt upgrade
apt search linux-image
apt install linux-image-extra-4.13.0-36-generic linux-image-4.13.0-31-generic
apt purge grub grub-pc grub-common
apt install grub-common grub-pc
exit
Finally we need to cleanly unmount everything else before unmounting the drive:
sudo umount /mnt/duck/proc
sudo umount /mnt/duck/dev
sudo umount /mnt/duck/run
sudo umount /mnt/duck/sys
sudo umount /mnt/duck
exit
Now the system can boot again (allowing me to write this update amongst other things)
Check out the [Jekyll docs][jekyll-docs] for more info on how to get the most out of Jekyll. File all bugs/feature requests at . If you have questions, you can ask them on [Jekyll Talk][jekyll-talk].
]]>Apart from the initial Jekyll build command I’ve been able to do most of the configuration and this post from a mobile device.
]]>function hmac-sha1 () { date > hmac-sha1.txt; openssl dgst -sha1 -mac HMAC -macopt hexkey:0000 $@ | tee -a hmac-sha1.txt; }
function sha1 () { date > sha1.txt; openssl dgst -sha1 $@ | tee -a sha1.txt; }
function crc () { date > crc.txt; crc32 $@ | tee -a crc.txt; }
sha1 <file-name>
hmac-sha1 <file-name>
crc <file-name>
sha1.txt
hmac-sha1.txt
crc.txt
