Shriharsh Acharya

Nix Mystery

Sun, 01 Feb 2026 22:16:30 +0545

I’ve been wanting to use nix for a long time, and it seems that the time has finally come.

Nix always has been something familiar but unknown to me for a while. I know Nix lets you manage packages in a declarative fashion and it is reproducible.

But in all honesty, these are just buzz words which I really don’t understand just yet. So, I’ll just look into what actually Nix is.

Setup

search?q=nix

Aparently, Nix is a package manager that works on a functional programming language, called Nix, which is interesting as I’m interested in functional programming.

I’m obviously not going to opt into using nixOS or nix for my host system just right now. For now, the middleground for me seems to just use nix in my host system to build a nixOS system and run it on QEMU.

PS: QEMU is a great tool to emulate a PC environment.

pacman -Q nix

Something I realized off the boat was that for some reason, nix has majority of their “useful” utilities and tool under an experimental feature, which seems quite odd.

sudo pacman -S nix

I’ll have to make sure that locked features like nix-shell and flake, I’ll have to add to: /etc/nix/nix.conf

experimental-features = nix-command flakes

nix –help

So aparently, nix uses flakes for packaging and reproducing builds, which seems analogous to cargo for rust. As, the nix package repository stores all the nix packages in form of nix expressions of sometimes a flake itself.

nix flake init

So, looking into how nix works, it seems to me that I’ve gone ahead and built a simple hierarchy of how my files are structured and how the flake is going to look, and named the configuration kanto.

nix flake init

├── flake.lock
├── flake.nix
├── hosts
│   └── kanto
│       ├── default.nix
│       ├── hardware.nix
│       ├── services.nix
│       └──users.nix
├── justfile
├── README.md
└── result -> /nix/store/jibberish-hash

Directories:

hosts/ - Holds configuration for multiple hosts
kanto/ - Holds configuration for kanto

Files:

default.nix  - entrypoint
hardware.nix  - fs and bootloader
users.nix  - user config 
services.nix  - daemons

Configuration

{…} : {}

Since, the most interesting part of nix is about, how I can “declare” my OS. So, I ended up writing:

default.nix

{ config, pkgs, ... }:

{
  imports = [ ./hardware.nix ./users.nix ./services.nix ];
  networking.hostName = "kanto";
  time.timeZone = "Asia/Kathmandu";
  system.stateVersion = "24.11";
}

{config,pkgs, ...}: : This essentially introduces my flake’s function which takes in a config, pkgs, and a variadic.

{ bunch of declarations } : This is the block, this returns an object with import, networking, time and system fields, which define our system.

nix build

This makes our configuration able to run on QEMU. Let’s try to build it:

nix run nixpkgs#nixos-rebuild -- build-vm --flake .#kanto

‘#’ here is the fragment specifier. But I liked to think of it as a package access specfier, like accessing the package from a flake.

It works, but I might’ve cheated, as I’ve already written some declarations in some of the files.

hardware.nix

{ config, ... }:

{

  boot.loader = {
    grub = {
      enable = true;
      efiSupport = true;
      device = "nodev";
    };
    efi.canTouchEfiVariables = true;
  };

  fileSystems."/" = {
    device = "/dev/disk/by-label/nixos";
    fsType = "ext4";
    options = [ "noatime" ];
  };

  fileSystems."/boot" = {
    device = "/dev/disk/by-label/BOOT";
    fsType = "vfat";
  };
  swapDevices = [
  { device = "/dev/disk/by-label/swap"; }
  ];
}

This defines my hardware, currently assumed that my system has simple dual partitions: and also have assumed a swap.

"/" - primary partition
"/boot" - boot partition

The fact that if you’ve understood the syntax of nix, this is very much readable.

Nix actually stores each of its rebuilds as generations and allows the user to boot into any of its builds, hence making it extremely tolerant to any faulty builds.

users.nix

{config,pkgs,...}:

{
  users.users.irhs = {
    isNormalUser = true;
    description = "Admin";
    extraGroups = [ "networkmanager" "wheel" ];
    openssh.authorizedKeys.keys= [
        "your-ssh-pub-key"
    ];
  };
  programs.zsh.enable = true;
}

Here, we’re just declaraing a simple user called “irhs” with hierarchy as:

users = {
    users = {
        irhs = {
            # above configurations 
        }
    }
}

This structure has a high resemblance to recursive structures defined in LISP.
'((
users . ((
 users . ((
     shri . ((
        ; above configuration
            ))
        ))
    ))
))

This essentially shows how the origin of nix was highly inspired from LISP and how it has vastly simplified it. In my mind, I’ve mostly been reiterating how nix seemed really familiar with my time configuring emacs.

Now for the final part, I have to ensure that I am able to remotely access the machine, so I have to setup a sshd, for which I’ll have to populate services.nix.

services.nix 

{ config, pkgs, ... }:
{
    services = {
      openssh = {
          enable = true;
          settings.PermitRootLogin = "no"; 
          settings.PasswordAuthentication = true;
        };
    };
}

This is relatively straight forward, and now if I build the OS.

building the system configuration...
Done. The virtual machine can be started by running /nix/store/2b59ryh0v0fan4wr8q0b04b2zniz4srp-nixos-vm/bin/run-kanto-vm

`run-kanto-vm`

Actually, all the packages that I intend on adding to my system in the future, are actually stored in a central repository /nix/store in my system. And it successfully boots into NixOS, but that is not our goal. We’ll have to try to ssh into it.

And well it works as well.

Finishing up

Nix isn’t just a package manager; it’s an abstraction layer over the messiness of Linux.

By treating my OS like my emacs configuration, with simpler syntax and large amount of packages. I can avoid imperative deficiencies like failing commands and expecting functional reliability of declaraing my operating system.

For anybody looking into this article, this is not something you should follow, I’ve only written this as a note to myself and to understand about Nix a little bit more.

Is it me or is it we?

Fri, 16 Jan 2026 22:16:30 +0545

I’m always amazed by how our society has developed and how we see value.

I’ve always seen value as something that benefits me.

But if one thinks about it, it is never about me, rather it is about us and how we as a society have developed over the years.

Only now that I have come to realize that I’m not being valued for what I do for myself rather what I have done for the society or for the species.

I’m not being valued in a group for the work I have done for myself, but for what change I contributed to.

“Love as a principle, order as a foundation, progress as a goal” ~Augste Comte

Ideals

Tue, 06 Jan 2026 22:16:30 +0545

Are you truly free?

Will you stay with nothing but your ideals?

Will you bring any value, or only your ideals?

Will your ideals struggle with you?

Are you truly able?

Will you follow your ideals even with the person you love?

Will you sell your dusty old laptop?

Will you leave that job—the one that gives you your “freedom”—to go live by yourself with nothing but the value you accumulated to make you “free”?

Are you truly strong?

Will your ideals change if they are proven at fault?

Will you have the courage to disagree?

Will you stick to your ideals when it matters most?

Designing an 8-bit ALU

Tue, 04 Feb 2025 09:49:24 +0545

Rather than overcomplicating things,lets start off with the design:

Design Decisions

To get a grip on the basics and to build a strong foundation, I decided to research prior ALU designs and go through articles and datasheets with solid community backing.

Lucky for me, I stumbled upon a goldmine—a detailed breakdown of the classic 74181 IC, a 4-bit ALU chip that became a standard reference for simple ALU design.

From its function table, I understood how the chip operates, including the variety of logic and arithmetic operations it supports.

However, after reading discussions about the 74181’s internal design, I noticed a bit of division in the community. Some love it for its elegance; others think it’s unnecessarily complex.

So, I decided to go with a more minimal and modular approach tailored to my own understanding.

And instead of sticking with a 4-bit design like the original 74181, I upgraded to an 8-bit ALU. This gave me more headroom for meaningful operations while still keeping the design manageable.

OPCODE Mapping (8-bit ALU)

To control the operations, I created a simple 4-bit OPCODE system, allowing for 16 unique instructions. Here’s a look at the operation mapping:

OPCODE	UNIT	OPERATION	DESCRIPTION
`0000`	AU	`ADDC`	Add with Carry
`0001`	AU	`SUBC`	Subtract with Carry
`0010`	AU	`ADDO`	Add with Overflow
`0011`	AU	`SUBO`	Subtract with Overflow
`1000`	LU	`XOR`	Bitwise XOR
`1001`	LU	`NOT`	Bitwise NOT
`1010`	LU	`AND`	Bitwise AND
`1011`	LU	`OR`	Bitwise OR
`1100`	LU	`NAND`	Bitwise NAND
`1101`	LU	`NOP`	No Operation
`1110`	LU	`XNOR`	Bitwise XNOR
`1111`	LU	`NOR`	Bitwise NOR

Final Design Specs

FLAGS

FLAG	Description
`OVERFLOW`	Only for signed addition operations
`ZERO`	Set if result is zero
`NEGATIVE`	Only for subtraction operations
`CARRY`	For additions exceeding 8-bit limits

BUS Layout

BUS	WIDTH
`INPUT_BUS`	8
`OP_CODE`	4
`OUTPUT_BUS`	8
`STATUS_IN`	1
`STATUS_OUT`	4

Workflow

My approach wasn’t exactly linear—I leaned into an iterative workflow, learning from each version of the build. Each iteration gave me new insights and helped polish the final design step by step.

Design Implementation & Selection

I experimented with multiple logic gates and missed a few things here and there.
Here’s my implementation for the AU, which is quite conventional.

Here, the AU performs the selection of operations specified in the table below.
Also, worth mentioning is the fact that the ALU only has 4 operations as opposed to the LU, so the LSB for this is just neglected.

OP_CODE	OPERATION
`x00`	`ADDC`
`x01`	`SUBC`
`x10`	`ADDO`
`x11`	`SUBO`

Similarly, the LU performs the Logical Operations, and since they’re a bit less tedious to implement, I just implemented all the 8 possible operations.

OP_CODE	OPERATION
`000`	`XOR`
`001`	`NOT`
`010`	`AND`
`011`	`OR`
`100`	`NAND`
`101`	`NOP`
`110`	`XNOR`
`111`	`NOR`

Note: The lack of the last bit of the input OPCODE is because it will be used to choose between the AU and the LU.

Finally, this is the fundamental block for the operation of the ALU — the mighty 1-bit ALU.

Now that the hard part of designing the fundamentals is done, the more complex-looking block comes into play, where all of the smaller blocks are copied and pasted to get a final design like this:

This implementation of the 8-bit ALU is very basic and might contain unnecessary operations.
Yet, I call it not unnecessary, as more or less all the required operations have to be implemented — and the added operations that are implemented within it are always dependent on the task to be accomplished.

Playing around with the final block, I implemented the input as 8-bit registers which can be manipulated by the user, and the output from the previous carry is fed back into the register as a part of operation in the ALU.

I personally didn’t get into the HDL or VHDL implementation of these circuits, as they were quite irrelevant and out of my expertise at the time.

References

About Digital Literacy

Tue, 11 Jun 2024 00:00:00 +0000

Introduction

Why is digital literacy important?

Since,the world isn’t all as developed uniformly as it has to,it is for sure that digital literacy is a term,only focusing on the developed/developing countries as the jargon we’re using doesn’t make sense for the people of ethiopia. So, the digital literacy is severely important, as most of the countries have been polluted with gadgets but haven’t have the the people without digital knowledge been given the proper exposure to learn about the technology. But at the same time technologies are being emphasized and embedded in daily acitivities. This what makes the people of lack of knowledge fall into the gap, a void. So,it is important to fill up this void, this gap in knowledge to make the everyday living of the people too in the same page as us.

How to be digitally literate:

In today’s world,digital literacy has only associated itself with the literacy of digital gadgets and mobile phones.But in nature,it is actually not just related to information literacy but also with curiosity. It is not about how much one is literate about a subject of digital gadgets, but what he does with the information he has. As a person born as a Gen-Z, I can’t call myself digitally illiterate at any point of my life. But for my parents who have lived to see the transition of the world from no digital devices to being full of them, are expected to be digitally illiterate.

But their age doesn’t hold their curiosity, my father calls himself a digitally illiterate but tries to use his phone to everybit, doesn’t know about it, but tries to rummage over everything configuration he is allowed.

This is what being digitally literate is,not about being able to only tap buttons to make something magically happen,but use digital things to your liking and your advantage as you like.

Build me a packet please!

Sat, 06 Apr 2024 00:00:00 +0000

Packets

tl;dr: Packet is built upon the protocol it is travelling in.It goes woosh woosh with essential data and also contains its size along with its type of data.

This is a physical packet

Trying to build a simple packet

➡️ Protocol:

A protocol a set of rules that a network connect should/could follow for uniformity of exchange. So,its not necessary but is.So,for now,lets us just assume a simple protocol of an arbitrary name of saltim.It’s just that easy,now as we’re done with the hard part.Now for the easy bit.

Some of the more commonly used protocols are:

1.TCP(Trasmission Control Protocol)↔️ 2.UDP(User Datagram Protocol)➡️ 3.FTP(File Transfer Protocol)🗃️ 4.IP(Internet Protocol)🌐

➡️ Designing a packet:

So,A packet in the most fundamental state is just pure data.Anything could be a packet.It could be you throwing a ball of binary 101010100110000001001 to your friend during the class or a president hitting the button for the nuclear missile to set its way with complex set of instructions within the packet to make sure of its authenticity.

So our packet in saltim which is a very basic packet would kind of look like this in high-level with the payload and all the attached info along with it.The data along with will be explained in.

➡️ The packet's data architecture.

So,from the above assumption of the saltim packet that we use.The saltim packet has the different parts to a structure in the packet:

1.The Payload

The payload to a data contains the important data to a packet, essentially,the data that is sent by the by any of the parties that are involved in the connection.

It could be anything of the sort of saying hello,to being a bash command being sent.

It is kind of impossible for one to decrypt what is said in the modern day encryption that is used for the packets that travel via selected protocols.

2.Size info

Yes,sorry guys,but size does matter.In case of packets,it is quite necessary for the packets to contain their size info to be attached else it is not possible to locate the end of the packet and the start of another packet as a connection has a flow of packets.A end info the packet end could be helpful to locate the end of the packet and make it easier for the location of the then packet.

3.Info data

A data in the payload can be a various types:xml,json,etc. So,for the data type to be known it could be helpful for the receiver to parse the data as the data received has a known structure.

{
    size-info:10,//assumed
    payload:"Turn On",
    end-info:0x1B39, 
    data-info:"json"    
}

4.End info

The endinfo contains an end pattern that the receiver is able to identify as a pattern of ending byte.It could be anything but it must be something that isn’t included in the payload data.ie.If the payload data is an ascii string anything out of the ascii range,ie,8 bit data we could make an ascii string.So,we could assume

0x1B39

a data passed as ending sequence as it is not included in the ascii range.Since the data isn’t passed in the ascii range,it packet would be considered ended and the packet read would be completely received.

WOOOOOOOOOOOO!! The packet is ready to be sent.

Ending note:

It could be said that this model of implementation of packet sending and networking is only a theoritical model that could be used for small implementation that are easily compromisable with various flaws and disadvantages, but yet,these were the only protocols that were able to build other more complex protocols,as they’re just a manifestation of smaller protocols.

Took an understanding of this video

My First Hackathon

Sun, 10 Mar 2024 00:00:00 +0000

My First Hackathon

It was a random call by my friend which led me into trying the hardware hackathon.

Spoiler: We built a bionic arm.

Pre-Story

Not the hardware part but as a whole, hardware hackathon to me, was really the first one I had attended. It was on a tight schedule because it was really in the midst of my internals but that’s out of topic. So, let us let it be.

I rushed to the hall where it were to be started. When I came, the time already had started and we were revealed the theme.

First 5 Hours

The theme was to create something that was sellable.

The first 5 hours were quite normal, we brainstormed, as all of us were quite new to it, we were very unsure of what to build and how to go about it. We took ideas from everyone and we stumbled on the idea of building a Smart Vacuum Cleaner. Not the most original but we were thinking of implementing a local positioning system.

It was given a thumbs up by the team members.

5-10 Hours

We on the first thought, of it to be easy and tried also of building a sort of heatmap of where the vacuum cleaner would suck the most dust and from that data we would provide it to the user and make them know about the specific spots of dust collection in the space.

For the designing part me and my other friend were assigned to it and built a diagram on the paper which kind of looked like this.

Pretty cute, isn’t it.

For the hardware implementation, we were allowed to use just the arduino nano along with the necessary components. I then shifted towards the software yet, it was about time I got really tired. I had spent most of my time trying to learn how to code the DAMN arduino. So, I also had gotten frustrated. So, I slept.

ZZzZZZZzzZZZzzZZZ

Right after I woke up. The guys had just made the thing move. YES IT ACTUALLY MOVED. They ended up re-wiring the whole thing and made the right adjustments for the robot by the help of Nirjal Da. But the revelation only lasted so long, they were tired so, I had to boot myself up and work on the software for the turning and rotation mechanisms.

10-15 Hours

I ended up implementing the rotation and learning about the pins and the motor driver that way. It was the time where I had learnt most during the hackathon. (Majority other was fucking around and playing around.)

Technical Part

So, for the motor drivers and the arduino part. This is what I understood that I could explain.

Arduinos are a variety of MCU. While the one provided to us nano is one which works in 5V as its supply. It usually can work with power supplied to it by the usb connected to the external device while flashing it.

For our circuitry, it works in the following way if it were to be simplified while sending the signals from the arduino to the motors.

(nano->m-driver->voltage-pins->motors).

Signal Types

Analog Signals: Analog Signals are the continuous signals.
Digital Signals: Digital Signals are discrete value containing signals.
PWM (Pulse Width Modulation): Is the process of modulation of a wave such that the wave is made a single way, by the use of digital signals.

So, we used the PWM supporting pins in the arduino nano to control the speed of the motor in using the enable a and enable b pins in the motor driver and the remaining 4 pins were utilized in supplying digital signal without PWM. Which solely sent data to either rotate or not to rotate the motor.

The code was pretty easy as it was a black box and we only had to use the arduino’s ide to flash and compile. It just required, setting up all the required data in the setup() function and have all the necessary data in the loop() function. The most important part about programming arduino I learnt was that. There shouldn’t be much or no use of loops because they interfere with the workings of the hardware and make it such that not enough supply is supplied to the components. So, always use an if statement.

15-24 Hours: The Curveball

Now, this is when we realized that life hit us with a curveball. Although we had ambitious plans of creating this/that but we weren’t the most prepared for it since we were new. We were naive, but curious. I tried my best to think of something that could bring a better implementation to our project. Nothing could. We weren’t able to implement the required algorithms and also we weren’t able to setup what we wanted. So, we had to scrap it.

So, in the time pressure, we built what we had in the pocket. All we had to do was to create a working hand and for the software, it was ready. (From the existent project, one of us had done.)

So, we did. I’m kinda tired cause its almost 1:00 am and I’m kinda of bored writing this soooooooo……

Shriharsh Acharya

Nix Mystery

Setup

search?q=nix

pacman -Q nix

nix –help

nix flake init

Configuration

{…} : {}

nix build

run-kanto-vm

Finishing up

Is it me or is it we?

Ideals

Are you truly free?

Are you truly able?

Are you truly strong?

Designing an 8-bit ALU

Design Decisions

OPCODE Mapping (8-bit ALU)

Final Design Specs

FLAGS

BUS Layout

Workflow

Design Implementation & Selection

References

About Digital Literacy

Build me a packet please!

Packets

Trying to build a simple packet

Ending note:

My First Hackathon

My First Hackathon

Pre-Story

First 5 Hours

5-10 Hours

10-15 Hours

Technical Part

Signal Types

15-24 Hours: The Curveball

01001110011001010111001001100100

`run-kanto-vm`