DEV Community: Tsiry Sandratraina

Bringing Rockbox's Legendary Audio Engine to the Modern Desktop: A Native Port for Linux and macOS

Tsiry Sandratraina — Sun, 21 Dec 2025 10:01:39 +0000

Remember the iPod Classic era? Back in 2010, I installed Rockbox on mine and was completely blown away. The default Apple firmware was fine, but Rockbox unlocked a whole new level of audio goodness:

High-quality parametric equalizer
Seamless crossfading
Advanced audio filters and DSP effects
Gapless playback, replay gain, and so much more

It turned my iPod into an audiophile's dream.

Fast forward to today: I no longer own an iPod, but my music library is bigger than ever, living on my Linux desktop and MacBook. I've tried pretty much every desktop music player out there - Clementine, Strawberry, Rhythmbox, even the big commercial ones, and none of them quite match that Rockbox audio quality. I missed it badly.

So, I decided to do something about it: port Rockbox to run natively on desktop Linux and macOS.

The Core Idea: Keep the Engine, Ditch the Old UI

Rockbox's audio processing core is incredible—it's lightweight, highly efficient, and packed with pro-level DSP features. The good news? All of that works perfectly when ported.

The challenge? Rockbox's UI was designed for low-res embedded screens (e.g., the iPod Classic's 320x240 pixels). It looks tiny and outdated on a modern 1080p+ desktop display.

My solution:

Run Rockbox in headless mode (completely disable the default SDL-- based GUI).
Build a brand-new, native graphical interface on top:
- GTK+ for Linux (integrates beautifully with GNOME, KDE, etc.)
- SwiftUI for macOS (modern, responsive, and feels right at home)

This way, you get the unbeatable Rockbox audio engine with a clean, modern UI that scales properly on big screens.

Current Status & What's Coming

The project is actively under development, and the core audio features are already there and sounding amazing. Playlist handling, library scanning, and playback work great.

On the roadmap:

Enhanced playlist management and search
Cross-device music library sync
Built-in scrobbling support (Rocksky)
Cross-platform sync improvements

It's 100% open source, and contributions are very welcome—whether it's code, testing, UI ideas, or packaging help.
Check it out, star the repo, try it, and let me know what you think!
GitHub Repo: https://github.com/tsirysndr/rockbox-zig
Tangled Repo: https://tangled.org/tsiry-sandratraina.com/rockbox-zig

Why This Matters to Me (and Maybe to You)

If you're an audio enthusiast running Linux or macOS and tired of compromising on sound quality, this could be the player you've been waiting for. Rockbox has been around forever for a reason, its DSP is still unmatched in many ways.

What about you? What's your current desktop music player? Do you miss any specific Rockbox features? Drop a comment, I'd love to hear your thoughts, suggestions, or even war stories from the iPod modding days!

How I Built My Own Last.fm Clone on Bluesky’s AT Protocol — Join the Beta!

Tsiry Sandratraina — Thu, 13 Mar 2025 14:24:10 +0000

The idea of tracking and sharing what I listen to has always fascinated me. I’ve been a long-time user of Last.fm, but I wanted something more open, decentralized, and built on modern protocols. That’s why I decided to build my own Last.fm alternative—a social music tracking platform running on Bluesky’s AT Protocol.

Now, I’m inviting early adopters to join the limited beta and help shape the future of this project! 🚀

Why Build a Last.fm Alternative?

Last.fm has been around for years, but I saw some limitations:

Walled garden: No true interoperability with decentralized social networks.
Limited control: Users don't fully own their listening data.
Feature stagnation: The core experience hasn't evolved much.
The Bluesky AT Protocol (ATProto) offers a decentralized social graph where users own their content and identity, making it the perfect foundation for a next-gen music scrobbling service.

How It Works

This project brings music tracking (scrobbling), sharing, and stats to Bluesky's AT Protocol. Here’s a high-level breakdown:

1️⃣ Scrobbling Tracks
I've built my own Rockbox fork that can send scrobbles automatically to the API.
It also supports Spotify, local players, and streaming services (via future integrations).
The API accepts “Now Playing” and track history data.

2️⃣ Bluesky AT Protocol for Social Feeds
Instead of a centralized database, users’ listening data is posted as ATProto records, making them portable.
Users can see a feed of their friends’ recently played tracks—just like a decentralized Last.fm friends list.
Playlists, top artists/albums, and listening trends are stored as ATProto posts, which can be discovered and shared.

3️⃣ User Trends and Analytics
Weekly/monthly listening trends (top artists, albums, tracks).
Open API for users to export their data.

Tech Stack

To ensure scalability, performance, and flexibility, I chose the following stack:

Backend: Node.js (Hono.js) – A fast, lightweight framework for handling API requests.
Database: Xata (PostgreSQL) – A managed database for storing scrobbles and user data.
Analytics: DuckDB – Efficient in-memory analytics for trends and insights.
Caching: DragonflyDB – A Redis-compatible, high-performance caching layer.
Microservices (Rust):
- Spotify Watcher: Tracks the user’s currently playing Spotify song.
- analytics Processor: Handles scrobbling data aggregation.
Protocol: Bluesky ATProto for decentralized data.
Frontend: React for the web UI.
Auth: Bluesky DID (Decentralized Identifiers).

What's Next?

I'm actively improving the platform and adding new features, but my long-term goal is to open-source the project so anyone can contribute, self-host, or build upon it. I believe in open and decentralized music tracking, and I’d love for the community to help shape it!

Join the Beta!

This project is still in its early days, but I’m opening a limited beta for those interested in trying it out. If you love music and want to explore a decentralized Last.fm alternative, sign up here:

➡️ Request Beta Access

I'd love your feedback! What features would make this the ultimate music tracking service? Let's discuss in the comments or on Bluesky.

🔵 Find me on Bluesky: @tsiry-sandratraina.com

Setting Up Your Base Workspace for Seamless Development 🧑‍💻

Tsiry Sandratraina — Thu, 01 Feb 2024 10:24:46 +0000

Welcome to the base workspace – a versatile foundation for all your projects! This environment comes equipped with a portable Docker setup, including pre-configured VSCode tunnels, all orchestrated through Terraform.

🚀 Usage

Clone the base-workspace repo :

git clone https://github.com/tsirysndr/base-workspace
cd base-workspace

Initialize Terraform:

terraform init

Apply the configuration:

terraform apply

This will create a Docker container named base-workspace with essential tools like pkgx, oh-my-posh, atuin, and the VSCode server pre-installed.

To connect to your environment, run:

docker logs base-workspace

Follow the provided VSCode tunnel instructions, and you're ready to roll!

You can also enter the environment directly using:

docker exec -it base-workspace bash

✨ Bonus

The environment comes pre-configured with oh-my-posh and atuin for an enhanced development experience.

🐚 Environments

Name	Description
devbox	devbox environment with vscode tunnels configured.
devenv	devenv environment with vscode tunnels configured.
flox	flox environment with vscode tunnels configured.
homebrew	homebrew environment with vscode tunnels configured.
nix	nix environment with vscode tunnels configured.
pkgx	pkgx environment with vscode tunnels configured.
default	Base environment with VSCode tunnels configured

Enhance your development workflow with this robust base workspace – tailored for efficiency and ease of use. Happy coding! 🚀

Streamline Your GitLab CI Configuration with Fluent GitLab CI - A Deno Module

Tsiry Sandratraina — Tue, 04 Jul 2023 06:20:27 +0000

Introduction

When it comes to setting up and managing GitLab CI configuration files, developers often seek simplicity, readability, and efficiency. Imagine a tool that allows you to generate GitLab CI configuration files with ease and fluency. Enter Fluent GitLab CI, a powerful Deno module that simplifies the process of creating GitLab CI configurations. In this article, we will explore the features, benefits, and usage of Fluent GitLab CI, along with code examples to demonstrate its capabilities.

Introducing Fluent GitLab CI

Fluent GitLab CI is a Deno module designed to simplify the process of generating GitLab CI configuration files. With Fluent GitLab CI, you can effortlessly create CI/CD pipelines by defining stages and jobs with custom scripts. This module brings ease and fluency to the creation of GitLab CI configurations, making it a valuable tool for developers looking to streamline their CI setup.

Getting Started

To get started with Fluent GitLab CI, you need to import the necessary classes from the module and define your stages and jobs. The Job class represents a single job in a GitLab CI pipeline, while the GitlabCI class is used to construct the overall CI configuration. By chaining methods and setting properties, you can create a comprehensive CI pipeline.

Exploring Fluent GitLab CI Features

Fluent GitLab CI offers several powerful features to simplify the creation of GitLab CI configurations. Firstly, you can define stages using the stages() method, specifying the order in which jobs will be executed. Each stage can consist of one or more jobs defined using the addJob() method.

Each job can have its own custom script, which is defined using the script() method. This allows you to include commands and actions specific to the job's purpose, such as compiling code, running tests, or deploying applications. Fluent GitLab CI also supports specifying dependencies between jobs using the needs() method, ensuring proper execution order within the pipeline.

To obtain the final GitLab CI configuration, you can use the toString() method, which returns the configuration as a string. This string can then be outputted or saved to a file.

Code Example

Let's take a closer look at an example that demonstrates the power of Fluent GitLab CI. Suppose you have a project with three stages: "build", "test", and "deploy". Within each stage, you want to define specific jobs.

import { GitlabCI, Job } from "https://deno.land/x/fluent_gitlab_ci/mod.ts";

const build = new Job().stage("build").script(`
  echo "Compiling the code..."
  echo "Compile complete."
`);

const unitTest = new Job().stage("test").script(`
  echo "Running unit tests... This will take about 60 seconds."
  sleep 60
  echo "Code coverage is 90%"
`);

const deploy = new Job().stage("deploy").script(`
  echo "Deploying application..."
  echo "Application successfully deployed."
`);

const gitlabci = new GitlabCI()
  .stages(["build", "test", "deploy"])
  .addJob("build-job", build)
  .addJob("unit-test-job", unitTest)
  .addJob("deploy-job", deploy);

console.log(gitlabci.toString());

gitlabci.write();

In this example, we define three jobs: "build-job", "unit-test-job", and "deploy-job". Each job is assigned to a specific stage and has its own custom script. The stages() method is used to define the order of the stages. Finally, we call the toString() method to obtain the GitLab CI configuration as a string and output it to the console. The write() method can be used to save the configuration to a file.

Benefits of Fluent GitLab CI

Fluent GitLab CI offers numerous benefits for developers. First and foremost, it simplifies the process of creating GitLab CI configurations, reducing the time and effort required. The fluent and expressive syntax of the module makes the configuration files more readable and maintainable.

By leveraging TypeScript and Deno compatibility, Fluent GitLab CI provides type safety and robustness in the CI configuration generation process. This helps catch errors and ensures that the configurations adhere to the expected structure.

Fluent GitLab CI empowers developers to create comprehensive CI/CD pipelines easily, improving their productivity and enhancing the overall development workflow. With its intuitive API and flexible features, Fluent GitLab CI is a valuable asset for any project utilizing GitLab CI.

Conclusion

Fluent GitLab CI provides developers with a powerful tool to generate GitLab CI configuration files easily and fluently. By leveraging the capabilities of this Deno module, developers can streamline their CI setup, improve productivity, and enhance the readability of their GitLab CI configurations. With Fluent GitLab CI, managing complex CI pipelines becomes a breeze. Give it a try and experience the efficiency and simplicity it brings to your GitLab CI workflows.

FluentDocker: Simplify Docker Image Generation with TypeScript

Tsiry Sandratraina — Wed, 28 Jun 2023 06:55:41 +0000

Introduction

Are you tired of writing lengthy Dockerfiles for your projects? Introducing FluentDocker, a powerful Deno module that allows you to generate Dockerfiles and build Docker images effortlessly using TypeScript. With FluentDocker, you can streamline your Docker image generation process, saving time and effort. In this article, we will explore how FluentDocker simplifies Docker image creation and demonstrates how you can leverage its fluent syntax to build Docker images with ease.

Getting Started

To begin using FluentDocker, you need to import the Dockerfile class from the module using the Deno runtime:

import { Dockerfile } from "https://deno.land/x/fluentdocker/mod.ts";

Building Docker Images with FluentDocker

FluentDocker enables you to define Docker images using a fluent syntax. Let's dive into a practical example of how to build a Docker image for a Node.js application:

const image = new Dockerfile()
  .from("node:18-alpine")
  .run("apk update")
  .expose(8080)
  .cmd("npx --yes serve -s -l 8080");

const dockerfile = image.toString();

console.log(dockerfile);

In the above example, we start by creating a new Dockerfile instance. Then, we chain the methods to define the Dockerfile instructions. We specify the base image using from(), run commands with run(), expose ports with expose(), and set the entrypoint with cmd(). Finally, we call toString() to obtain the generated Dockerfile content, which we log to the console.

Building Docker Images

Once you have defined your Dockerfile using FluentDocker, you can proceed to build the Docker image. The build() method takes in the build context directory and the desired image name as parameters:

image.build(".", "node-app-example");

In the example above, we specify the build context as the current directory (.) and provide the desired image name (node-app-example). FluentDocker takes care of the Docker image build process, providing a seamless experience.

Conclusion

FluentDocker empowers developers to streamline the process of Docker image generation using TypeScript. With its fluent syntax and easy-to-use API, FluentDocker simplifies the creation of Dockerfiles, allowing you to define instructions in a clear and concise manner. By eliminating the need to write Dockerfiles manually, FluentDocker saves time and reduces errors in the image build process.

Ready to simplify your Docker image generation? Give FluentDocker a try and experience the power of TypeScript for Docker. Happy coding!

Simplify Your Development Environment Setup with 'setup-crosup' GitHub Action

Tsiry Sandratraina — Thu, 22 Jun 2023 13:47:21 +0000

Introduction

Setting up your development environment can often be a time-consuming process, especially when working with ChromeOS, MacOS or various Linux distributions. However, with the new setup-crosup GitHub Action, you can effortlessly streamline the installation and setup of Crosup CLI in your workflows. In this article, we will explore how to leverage this powerful GitHub Action to supercharge your development process.

What is 'setup-crosup' GitHub Action?
Getting Started
2.1 Prerequisites
2.2 Setting up 'setup-crosup' in your Workflow
Customizing the Action
3.1 Specifying the Crosup Version
3.2 Adding Packages for Installation
Verifying the Installation
4.1 Checking Crosup Version
4.2 Verifying Installed Packages
Conclusion

What is 'setup-crosup' GitHub Action?

The setup-crosup GitHub Action is a powerful tool that simplifies the process of downloading, installing, and setting up Crosup CLI in your GitHub Actions workflows. It eliminates the hassle of manual installation steps and ensures a consistent and reliable development environment across different platforms.

Getting Started

2.1 Prerequisites:

Before diving into using 'setup-crosup', ensure you have the following prerequisites:

A GitHub repository where you want to integrate Crosup CLI.
Basic knowledge of GitHub Actions and workflows.

2.2 Setting up 'setup-crosup' in your Workflow:

To integrate 'setup-crosup' into your GitHub Actions workflow, follow these steps:

Open your repository and navigate to the .github/workflows directory.
Create a new YAML file (e.g., crosup-setup.yml).
Copy and paste the following code into the YAML file:

Copy code
name: Setup Crosup
on:
  push:
    branches:
      - master
  pull_request:
    branches:
      - master
  workflow_dispatch:

jobs:
  setup-superviseur:
    runs-on: ubuntu-latest
    continue-on-error: true
    steps:
      - name: Install Nix
        uses: DeterminateSystems/nix-installer-action@v4
      - name: Setup Crosup
        uses: tsirysndr/setup-crosup@v1
        with:
          version: 'v0.4.8'
          # Add packages to install here
          packages: |
            deno
            zig
      - name: Verify Crosup
        run: crosup --version
      - name: Verify Deno
        run: deno --version
      - name: Verify Zig
        run: zig version

Customizing the Action

3.1 Specifying the Crosup Version:

You can specify the desired version of Crosup CLI by modifying the version parameter in the 'Setup Crosup' step of the workflow YAML. Replace 'v0.4.8' with your preferred version.

3.2 Adding Packages for Installation:

If you need to install additional packages along with Crosup CLI, simply add them to the packages parameter, separated by newlines. For example, to install Deno and Zig, modify the packages parameter as shown in the example YAML above.

Verifying the Installation

After setting up 'setup-crosup' in your GitHub Actions workflow, it's essential to verify the successful installation and configuration of Crosup CLI and any additional packages you specified. Let's explore how you can perform these verifications:

4.1 Checking Crosup Version

To ensure that Crosup CLI has been installed correctly, you can add a verification step in your workflow. In the example YAML, we've included a step named "Verify Crosup" that runs the command ``crosup --version. This command will display the version of Crosup installed, confirming its successful setup.

4.2 Verifying Installed Packages

If you specified additional packages to be installed alongside Crosup, it's crucial to verify their installation as well. In the example YAML, we've included verification steps for Deno and Zig. The commands deno --version and zig version respectively check the versions of Deno and Zig installed.

By performing these verification steps, you can ensure that all the necessary components of your development environment, including Crosup CLI and any additional packages, are successfully set up and ready to use.

Conclusion

With the setup-crosup GitHub Action, the process of setting up your development environment becomes a breeze. Say goodbye to manual installation steps and hello to streamlined workflows. In this article, we explored the features and benefits of setup-crosup, learned how to integrate it into your GitHub Actions workflow, and customized it to suit your requirements.

Now, you can simplify your development environment setup on Chromebook/ChromeOS, MacOS or any Linux distribution, saving time and effort in the process. Get started with setup-crosup today and enjoy a hassle-free development experience!

Remember, automation is the key to unlocking your productivity potential as a developer. Embrace the power of setup-crosup and elevate your development workflow to new heights. Happy coding!

Introducing CrosUp: Simplifying Package Management with Nix for Any Linux Distro or macOS

Tsiry Sandratraina — Sun, 18 Jun 2023 18:03:52 +0000

Introduction

Managing packages and dependencies is an essential part of every developer's life. However, it can often be a complex and time-consuming process, especially when dealing with different operating systems and package managers. But fear not! We are thrilled to introduce CrosUp, an open-source command-line tool that revolutionizes package management by seamlessly integrating Nix into your development environment. With CrosUp, you can now effortlessly search for, install, and manage packages from the Nix package registry on any Linux distribution or macOS system.

Simplify Your Development Environment

CrosUp is designed with simplicity and convenience in mind. Gone are the days of struggling with intricate Nix setups and configuration files. CrosUp streamlines the entire process, providing a fully automated installation experience that abstracts away the complexity of managing packages with Nix.

Search and Install Made Easy

Finding the right package is crucial for any development project. With CrosUp, searching for packages from the Nix package registry becomes a breeze. Simply run crosup search <package-name>, and let CrosUp handle the rest. Whether you need the latest version of a popular library or a specific tool for your project, CrosUp enables you to discover and install packages effortlessly.

Seamless Integration with Your Workflow

CrosUp goes beyond package installation. It enhances your development workflow by providing a seamless integration with tools you rely on. By running crosup init <package-name>, CrosUp automatically sets up the package for your project, ensuring that it is readily available for use. Say goodbye to tedious manual configurations and hello to productivity!

Cross-Platform Compatibility

One of the standout features of CrosUp is its ability to work across various Linux distributions and macOS. It eliminates the need for developers to juggle different package managers and ensures a consistent experience regardless of the operating system. With CrosUp, you can enjoy the benefits of Nix's powerful package management on your preferred platform.

Open-Source and Community-Driven:
CrosUp is an open-source project, built by developers for developers. The code repository on GitHub (https://github.com/tsirysndr/crosup) is freely accessible, allowing you to contribute, provide feedback, and collaborate with other members of the community. Join us in making package management a seamless experience for everyone!

Conclusion

CrosUp is the game-changing CLI tool that simplifies package management with Nix for Linux and macOS. By abstracting away the complexities and providing a user-friendly interface, CrosUp enables developers to effortlessly search, install, and manage packages from the Nix package registry. Embrace a seamless and productive workflow with CrosUp, and say goodbye to the hassle of package management. Try CrosUp today and experience the future of simplified development environments!

Streamline Your Development Environment Setup on ChromeOS and Linux

Tsiry Sandratraina — Sat, 10 Jun 2023 11:27:09 +0000

Introduction

Setting up a development environment on a new Chromebook (ChromeOS) or any Linux distribution can be a time-consuming and daunting task. But fear not! Introducing Crosup, a powerful command-line tool designed to simplify and expedite the process. With Crosup, you can swiftly configure your development environment, install essential tools, and get coding in no time. In this article, we will explore the features, installation process, usage, and configuration options of Crosup, empowering you to streamline your development workflow.

Features That Make Crosup Stand Out

Compatibility: Crosup is compatible with various operating systems, including ChromeOS, Debian-based Linux distributions, OpenSUSE, Fedora, RedHat, CentOS, Alpine, Arch, and Gentoo. It ensures a seamless experience regardless of your preferred platform.
Easy Installation: With a single command, you can quickly install Crosup on your machine. Just run bash <(curl -sSL https://raw.githubusercontent.com/tsirysndr/crosup/master/install.sh) and let the magic unfold.
Developer Tools Galore: Crosup provides an extensive collection of developer tools ready to be installed. From Docker, Nix, and Homebrew to VS Code, fzf, and kubectl, Crosup has you covered.
Avoid Maintaining Custom Bash Scripts: Crosup eliminates the need to maintain custom bash scripts for setting up your development environment. Instead, it offers a standardized and easily configurable solution that saves you time and effort.

Installation Made Simple

To get started with Crosup, you need to execute a straightforward installation process. Just follow the command mentioned earlier, and Crosup will be up and running on your system.

Usage Made Easy

Crosup's intuitive user interface simplifies the installation of developer tools. By executing the crosup install command, you can effortlessly install various tools based on your requirements. Additionally, Crosup offers subcommands like help and init to provide further assistance and generate default configuration files.

Streamlining Your Workflow with Configuration:
Crosup employs a configuration file, Crosfile.toml, to determine the tools to be installed. By default, Crosup includes an embedded configuration, but you can generate a default configuration file using the crosup init command. The configuration file, written in HCL/TOML format, allows you to specify tools, packages, version checks, pre- and post-installation commands, and even dependencies.

Example Configuration for Debian-based System:

We'll explore a minimal Crosfile.toml configuration, which installs Vim and Git:

# Crosfile.toml
packages = [
  "vim",
  "git"
]

Contributing and License

Crosup is an open-source project, welcoming contributions, bug reports, and feature requests. If you're interested in improving Crosup, check out the project's CONTRIBUTING guidelines. Crosup is licensed under the MIT License, enabling you to freely use, modify, and distribute the tool.

Conclusion

Crosup is your go-to command-line tool for quickly setting up a development environment on ChromeOS and various Linux distributions. Its compatibility, simplicity, and extensive collection of developer tools make it a must-have for developers seeking an efficient workflow. With Crosup, you can bid farewell to lengthy setup processes and the need to maintain custom bash scripts, allowing you to focus on what you do best—coding.

Developing on ChromeOS: Exploring the ChromeOS Flex and Nix Combo

Tsiry Sandratraina — Fri, 26 May 2023 07:40:13 +0000

Introduction

Developers have traditionally relied on Windows, macOS, or Linux distributions as their primary development environments. However, with the advancements in ChromeOS, the operating system developed by Google, it's worth exploring the possibilities it offers for developers. In this article, we will dive into ChromeOS as a development environment and explore the combination of Crostini and Nix to enhance your development workflow.

ChromeOS: embracing the cloud

ChromeOS is an operating system designed around the Chrome web browser, emphasizing cloud-based applications and services. While not initially considered a full-fledged development platform, ChromeOS has evolved and now offers options to support developers.

Linux Support with Crostini

One of the key features that make ChromeOS more developer-friendly is Crostini. Crostini enables the execution of a Linux container within the ChromeOS environment. This Linux container provides access to a terminal, package manager, and the ability to run Linux applications, opening up the door to a range of development possibilities.

Nix: Reproducible Environments

Nix, a powerful package manager and build system used primarily in the Linux ecosystem, can significantly enhance your development workflow on ChromeOS. With Nix, you can define your development environment as a set of packages and configurations, ensuring reproducible builds and the ability to create isolated development environments.

Installing Nix

To install Nix on your ChromeOS device, follow these steps:

Open a terminal in your ChromeOS environment (using Crostini).
Run the following command to download and execute the Nix installation script:

curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install

Follow the instructions presented during the installation process. The script will guide you through setting up Nix and configuring your environment.

Once the installation is complete, you'll have Nix available in your ChromeOS environment.

Unlocking Development Potential

Combining ChromeOS and Nix can unlock new possibilities for developers on Chromebooks. The Linux environment provided by Crostini allows you to leverage the Linux ecosystem and run various development tools and programming languages. Nix ensures reproducibility and simplifies the sharing of development setups across different machines.

Conclusion

While ChromeOS was initially perceived as a limited platform for development, the introduction of Crostini, along with the reproducibility of Nix, has expanded its potential as a viable development environment. Developers can now harness the power of ChromeOS, leverage Linux tools and applications and ensure consistent development setups with Nix. While ChromeOS may not be suitable for all development workflows, it's certainly worth exploring for web and cloud-based development tasks.

Introducing Superviseur - A process supervisor for local development

Tsiry Sandratraina — Sun, 19 Mar 2023 15:50:20 +0000

Are you tired of manually starting and stopping all the services you need for local development? Have you ever wished there was a tool that could handle this for you? Look no further than Superviseur!

Superviseur is a simple process supervisor for UNIX-like systems that allows you to manage executables, WASM, and Docker containers all from one place. It is perfect for local development environments where you need to manage multiple services simultaneously.

Installation is easy. Simply clone the repository and compile using the following commands:

brew install protobuf # macOS
sudo apt-get install -y protobuf-compiler # Ubuntu/Debian
curl -fsSL https://bun.sh/install | bash
git clone https://github.com/tsirysndr/superviseur
cd superviseur/webui && bun install && bun run build && cd ..
cargo install --path .

Superviseur is still in the alpha phase, so be warned that it may be unstable. However, the tool is already quite powerful and has a lot of features. You can download the latest release for your platform here.

Once you have installed Superviseur, you can start using it by starting the daemon and initializing a new project using the following command:

superviseur daemon &
superviseur new

This will create a Superfile.hcl file in the current directory with an example configuration that you can modify to suit your needs. You can then start a service using the superviseur start <service_name> command. You can check the status of a service using the superviseur status <service_name> command.

Superviseur also has a web UI that you can use to manage your services. To start the web UI, simply use the superviseur ui command.

Superviseur is still a young project, and there are plenty of ways you can contribute. If you encounter a bug or have a feature request, please submit an issue on the GitHub repository. If you would like to contribute to the project, there are a number of open issues and feature requests that you can work on. You can also contribute by improving the documentation or helping to test the tool.

In conclusion, Superviseur is a powerful and easy-to-use process supervisor that can help you manage your local development environment. Give it a try and let us know what you think!

Introducing TuneIn-CLI: A Command-Line Interface to Browse and Listen to Thousands of Radio Stations Globally

Tsiry Sandratraina — Fri, 24 Feb 2023 16:34:04 +0000

Are you a fan of radio stations, and looking for a way to listen to them from your terminal? Then you'll love TuneIn-CLI, an open-source project that allows you to browse and play thousands of radio stations worldwide without leaving your terminal.

In this blog post, we will introduce TuneIn-CLI, its installation process, usage, and features. TuneIn-CLI is a lightweight and easy-to-use command-line tool developed using Rust, an efficient and modern programming language. It uses TuneIn's public APIs to browse and fetch radio stations data from all around the world.

Installation

TuneIn-CLI is available for macOS and Linux platforms. You can download and install the latest version from the official GitHub repository or via Homebrew on macOS/Linux.

brew install tsirysndr/tap/tunein

Usage

TuneIn-CLI offers four subcommands: browse, play, search, and help. You can browse all available radio stations with the browse command, play a specific radio station with the play command, search for a station with the search command, and get help with the help command.

For example, to search for a radio station, you can run:

tunein search "BBC Radio 1"

And the CLI will display a list of available radio stations with their unique IDs.

To play a specific station, you can use the play command with the station name or ID:

tunein play "alternativeradio.us"

Features

TuneIn-CLI offers several features that make it a unique and powerful tool for radio lovers. Some of these features include:

Global Coverage: TuneIn-CLI supports thousands of radio stations worldwide, making it easy to discover and listen to new stations from different countries and regions.
Search: You can search for radio stations by name, genre, language, location, and other criteria to find stations that match your interests.
Play: TuneIn-CLI allows you to play radio stations.
Easy Navigation: You can browse radio stations by genre, language, location, and popularity to quickly find stations that match your interests.
Open-Source: TuneIn-CLI is an open-source project, which means that anyone can contribute to its development, report issues, or suggest new features.

Conclusion

TuneIn-CLI is a powerful and user-friendly command-line tool that allows you to browse and listen to thousands of radio stations worldwide without leaving your terminal. With its intuitive interface, powerful search capabilities, and global coverage, TuneIn-CLI is an excellent tool for radio enthusiasts and anyone looking for a unique and exciting way to discover new radio stations.

If you're interested in exploring thousands of radio stations across the globe right from your terminal, be sure to check out 'tunein-cli' on GitHub. The project is open-source, and we welcome contributions from developers like you. You can find the project repository here: https://github.com/tsirysndr/tunein-cli

Building a Chromecast Plugin for my Rust Music Player Project

Tsiry Sandratraina — Sun, 19 Feb 2023 05:50:26 +0000

Recently, I built a Chromecast plugin for my Rust-based music player project on Github. In this blog post, I will walk you through the steps I took to build the plugin, and highlight some of the key features and design decisions that went into its development.

Overview

My music player project was originally built as a command-line tool, but I wanted to extend its functionality to support casting audio to Chromecast devices. To achieve this, I built a new Rust module called "Chromecast", which defines a struct that implements the "Addon" and "Player" traits in my player's architecture.

pub trait Addon {
    fn name(&self) -> &str;
    fn version(&self) -> &str;
    fn author(&self) -> &str;
    fn description(&self) -> &str;
    fn enabled(&self) -> bool;
    fn set_enabled(&mut self, enabled: bool);
}

#[async_trait]
pub trait Player {
    async fn play(&mut self) -> Result<(), Error>;
    async fn pause(&mut self) -> Result<(), Error>;
    async fn stop(&mut self) -> Result<(), Error>;
    async fn next(&mut self) -> Result<(), Error>;
    async fn previous(&mut self) -> Result<(), Error>;
    async fn seek(&mut self, position: u32) -> Result<(), Error>;
    async fn load_tracks(
        &mut self,
        tracks: Vec<Track>,
        start_index: Option<i32>,
    ) -> Result<(), Error>;
    async fn play_next(&mut self, track: Track) -> Result<(), Error>;
    async fn load(&mut self, track: Track) -> Result<(), Error>;
    async fn get_current_playback(&mut self) -> Result<Playback, Error>;
    async fn get_current_tracklist(&mut self) -> Result<(Vec<Track>, Vec<Track>), Error>;
    async fn play_track_at(&mut self, position: u32) -> Result<(), Error>;
    async fn remove_track_at(&mut self, position: u32) -> Result<(), Error>;
    fn device_type(&self) -> String;
    fn disconnect(&mut self) -> Result<(), Error>;
}

Design and Implementation

The Chromecast struct contains several fields, including the device name, version, author, description, host and port, client connection, transport ID, session ID, current playback status, and a CastPlayer instance for sending media commands to the Chromecast device.

One of the most important methods in the Chromecast struct is "connect()", which connects to the Chromecast device and launches the Music Player App. This method uses the "CastDevice" and "CastDeviceApp" structs from the Rust crate "chromecast" to establish a connection and retrieve the transport and session IDs required for media playback.

The Chromecast struct also implements the "Player" trait, which defines methods for media playback, such as "play()", "pause()", "stop()", "seek()", and "set_volume()". These methods use the "CastPlayer" instance to send media commands to the Chromecast device over the established connection.

#[async_trait]
impl<'a> Player for Chromecast<'a> {
    async fn play(&mut self) -> Result<(), Error> {
        self.cmd_tx
            .as_ref()
            .unwrap()
            .send(CastPlayerCommand::Play)
            .unwrap();
        Ok(())
    }

    async fn pause(&mut self) -> Result<(), Error> {
        self.cmd_tx
            .as_ref()
            .unwrap()
            .send(CastPlayerCommand::Pause)
            .unwrap();
        Ok(())
    }

    async fn stop(&mut self) -> Result<(), Error> {
        self.cmd_tx
            .as_ref()
            .unwrap()
            .send(CastPlayerCommand::Stop)
            .unwrap();
        Ok(())
    }

    async fn next(&mut self) -> Result<(), Error> {
        self.cmd_tx
            .as_ref()
            .unwrap()
            .send(CastPlayerCommand::Next)
            .unwrap();
        Ok(())
    }

    async fn previous(&mut self) -> Result<(), Error> {
        self.cmd_tx
            .as_ref()
            .unwrap()
            .send(CastPlayerCommand::Previous)
            .unwrap();
        Ok(())
    }
 // ...
}

Conslusion

In conclusion, I have developed a Rust-based Chromecast plugin for my music player project on GitHub. The plugin allows users to cast their music playback to a Chromecast device with ease. I hope that this plugin will help enhance the user experience for our music player users.

This project is open source, and we welcome contributions from the community to help improve the plugin. If you are interested in contributing to the project, please feel free to check out the project's GitHub page and submit a pull request or open an issue. We appreciate any feedback and contributions that can help us make the plugin better.

DEV Community: Tsiry Sandratraina

Bringing Rockbox's Legendary Audio Engine to the Modern Desktop: A Native Port for Linux and macOS

The Core Idea: Keep the Engine, Ditch the Old UI

Current Status & What's Coming

Why This Matters to Me (and Maybe to You)

How I Built My Own Last.fm Clone on Bluesky’s AT Protocol — Join the Beta!

Why Build a Last.fm Alternative?

How It Works

Tech Stack

What's Next?

Join the Beta!

Setting Up Your Base Workspace for Seamless Development 🧑‍💻

🚀 Usage

✨ Bonus

🐚 Environments

Streamline Your GitLab CI Configuration with Fluent GitLab CI - A Deno Module

Introduction

Introducing Fluent GitLab CI

Getting Started

Exploring Fluent GitLab CI Features

Code Example

Benefits of Fluent GitLab CI

Conclusion

FluentDocker: Simplify Docker Image Generation with TypeScript

Introduction

Getting Started

Building Docker Images with FluentDocker

Building Docker Images

Conclusion

Simplify Your Development Environment Setup with 'setup-crosup' GitHub Action

Introduction

Table of Contents

What is 'setup-crosup' GitHub Action?

Getting Started

2.1 Prerequisites:

2.2 Setting up 'setup-crosup' in your Workflow:

Customizing the Action

3.1 Specifying the Crosup Version:

3.2 Adding Packages for Installation:

Verifying the Installation

4.1 Checking Crosup Version

4.2 Verifying Installed Packages

Conclusion

Introducing CrosUp: Simplifying Package Management with Nix for Any Linux Distro or macOS

Introduction

Simplify Your Development Environment

Search and Install Made Easy

Seamless Integration with Your Workflow

Cross-Platform Compatibility

Conclusion

Streamline Your Development Environment Setup on ChromeOS and Linux

Introduction

Features That Make Crosup Stand Out

Installation Made Simple

Usage Made Easy

Example Configuration for Debian-based System:

Contributing and License

Conclusion

Developing on ChromeOS: Exploring the ChromeOS Flex and Nix Combo

Introduction

ChromeOS: embracing the cloud

Linux Support with Crostini

Nix: Reproducible Environments

Installing Nix

Unlocking Development Potential

Conclusion

Introducing Superviseur - A process supervisor for local development

Introducing TuneIn-CLI: A Command-Line Interface to Browse and Listen to Thousands of Radio Stations Globally

Installation

Usage

Features

Conclusion

Building a Chromecast Plugin for my Rust Music Player Project

Overview

Design and Implementation

Conslusion