Forem: Jaipal001

64-bit bootloader from scratch in AT&T assembly, Part-9

Jaipal001 — Thu, 05 Feb 2026 11:27:40 +0000

Repo link

Makefile

# $@ = target file
# $< = first dependency
# $^ = all dependencies

LDFLAGS =  --oformat binary -N

CFLAGS = -ffreestanding -fno-pie

all: run

out/%.o: %.asm
    as -o $@ $<

bin/kernel: out/kernel.o
    ld -o $@ -T../link.ld  $(LDFLAGS) $^

bin/bootsect: out/bootloader.o
    ld -o $@ -Ttext 0x7c00 $(LDFLAGS) $<

os-img.bin: bin/bootsect bin/kernel
    cat $^ > $@
    truncate -s 10240 $@

run: os-img.bin
    qemu-system-x86_64 -drive format=raw,file=$<

64-bit bootloader from scratch in AT&T assembly, Part-8

Jaipal001 — Thu, 05 Feb 2026 11:27:40 +0000

Repo link

os-scratch

Makefile

# $@ = target file
# $< = first dependency
# $^ = all dependencies

LDFLAGS =  --oformat binary -N

CFLAGS = -ffreestanding -fno-pie

all: run

out/%.o: %.asm
    as -o $@ $<

bin/kernel: out/kernel.o
    ld -o $@ -T../link.ld  $(LDFLAGS) $^

bin/bootsect: out/bootloader.o
    ld -o $@ -Ttext 0x7c00 $(LDFLAGS) $<

os-img.bin: bin/bootsect bin/kernel
    cat $^ > $@
    truncate -s 10240 $@

run: os-img.bin
    qemu-system-x86_64 -drive format=raw,file=$<

64-bit bootloader from scratch in AT&T assembly, Part-7

Jaipal001 — Thu, 05 Feb 2026 11:09:12 +0000

Btw, save that bootloader in seperate file as bootloader.asm

Bootloader full code

.code16
.org 0

.text
.global _start

_start:
    # Segment setup
    xor %ax, %ax
    mov %ax, %ds
    mov %ax, %es
    mov %ax, %ss

    # Stack setup
    mov $0x9c00, %bp
    mov %bp, %sp

    # Load Kernel from Disk
    mov $0x1000, %ax     # Segment 0x1000
    mov %ax, %es         # ES now points to 0x1000
    xor %bx, %bx         # Offset 0
    # Destination is ES:BX -> (0x1000 * 16) + 0 = 0x10000
    mov $2, %ah              # BIOS read sector function
    mov $8, %al              # Number of sectors to read (adjust as needed)
    xor %ch, %ch             # Cylinder 0
    mov $2, %cl              # Sector 2 (Sector 1 is the bootloader)
    xor %dh, %dh             # Head 0
    int $0x13

    jc disk_error
    jmp disable_int

disk_error:
    mov $disk_err_msg, %dx
    call print
    call println

disable_int:
    cli
    lgdt gdtp
    lidt idt

    mov %cr0, %eax    # This works in 16-bit mode!
    or $0x1, %eax     # Modify the 32-bit register
    mov %eax, %cr0    # Write it back

    movw $(gdt_data_segment - gdt_start), %ax
    movw %ax, %ds
    movw %ax, %es
    movw %ax, %es
    movw %ax, %fs
    movw %ax, %gs
    movw %ax, %ss

    ljmp $(gdt_code_segment - gdt_start), $entry32

print:
    lodsb
print_loop:
    inb (%dx), %al
    cmp $0, %al
    je print_end
    mov $0x0e, %ah
    mov $0x07, %bl
    int $0x10
    add $1, %dx
    jmp print_loop
print_end:
    ret

println:
    mov $0x0e, %ah
    mov $0xa, %al
    int $0x10
    mov $0x20, %al
    int $0x10
    ret

.code32
entry32:
    # Proper 32-bit segment initialization
    movw $(gdt_data_segment - gdt_start), %ax
    movw %ax, %ds
    movw %ax, %es
    movw %ax, %ss

    # 1. Setup Paging Structures
    mov $0x1000, %edi
    mov %edi, %cr3
    xor %eax, %eax
    mov $4096, %ecx
    rep stosl

    mov %cr3, %edi
    movl $0x2003, (%edi)         # PML4 -> PDPT
    movl $0x3003, 0x1000(%edi)    # PDPT -> PD
    movl $0x00000083, 0x2000(%edi)# PD -> 2MB Huge Page (Identity map 0-2MB)

    # 2. Enable PAE (FIXED)
    mov %cr4, %eax
    or $(1 << 5), %eax
    mov %eax, %cr4               # Write back to register

    # 3. Enable Long Mode via EFER
    mov $0xC0000080, %ecx
    rdmsr
    or $(1 << 8), %eax           # LME Bit
    wrmsr

    # 4. Enable Paging
    mov %cr0, %eax
    or $(1 << 31), %eax          # PG Bit
    mov %eax, %cr0

    # 5. Jump to 64-bit
    lgdt gdt64_ptr
    ljmp $0x08, $entry64

.code64
entry64:
    mov $KERNEL_OFFSET, %rax
    call *%rax

print_cli:
    mov $0xb8000, %ecx # VIDEO_MEMORY
print_loop_cli:
    # edx = str
    mov $0, %eax
    movb (%edx), %al   # str[i]
    mov $0x0f, %ah    # white fg, black bg
    cmp $0, %al
    je print_end_cli
    mov %ax, (%ecx)
    add $2, %ebx
    add $2, %ecx
    add $1, %edx
    jmp print_loop_cli
print_end_cli:
    ret

println_cli:
    mov $0xb8000, %ecx # VIDEO_MEMORY

    mov $0x0f0a, %eax  # 0f\n
    add %ebx, %ecx
    mov %eax, (%ecx)
    mov $1, %ebx
    ret


/* GDT */
.align 16
gdtp:
    .word gdt_end - gdt_start - 1
    /* .long (0x07C0 << 4) + gdt */
    .long gdt_start

gdt_start:
    .quad 0x0000000000000000    #   Null Descriptor
gdt_code_segment:
    #    Segment limit  Base address
    .word 0xffff,       0x0000
    .byte 0x00        # Base
    # 1st  flags: (present) 1    (privilege)   0                    0         (descriptor type)1 -> 1001b
    # Type flags: (code)    1    (conforming)  0        (readable)  1         (accessed)       0 -> 1010b
    # 10011010
    .byte 0x9a
    # 2nd  flags: (granularity) 1    (32-bit default) 1    (64-bit segment) 0    (available)   0 -> 1100b
    .byte 0xcf
    .byte 0x00        # Base

gdt_data_segment:
    #    Segment limit  Base address
    .word 0xffff,       0x0000
    .byte 0x00        # Base
    # 1st  flags: (present) 1    (privilege)   0                    0         (descriptor type)1 -> 1001b
    # Type flags: (code)    0    (conforming)  0        (readable)  1         (accessed)       0 -> 1010b
    # 10010010
    .byte 0x92
    # 2nd  flags: (granularity) 1    (32-bit default) 1    (64-bit segment) 0    (available)   0 -> 1100b
    .byte 0xcf
    .byte 0x00        # Base

gdt_end:

# Where docs for 64-bit GDT? IDK, just copy it
# 64-bit GDT
.align 16
gdt64:
    .quad 0                      # Null
    .quad 0x00209a0000000000     # Code: L-bit set, D-bit clear
    .quad 0x0000920000000000     # Data
gdt64_ptr:
    .word . - gdt64 - 1
    .quad gdt64                  # 64-bit base

/* IDT */
idt:
    .word 0
    .long 0

running_kernel: .asciz "Trying to run Kernel"
disk_err_msg:   .asciz "Can't load kernel from disk"

KERNEL_OFFSET: .long 0x2000
BOOT_DRIVE:    .byte 0

.fill 510-(.-_start), 1, 0
.word 0xAA55

Makefile in next par

64-bit bootloader from scratch in AT&T assembly, Part-6

Jaipal001 — Thu, 05 Feb 2026 11:06:43 +0000

Now make a new file for kernel as kernel.asm

.code64
.text

.global _start
_start:
    mov $0xb8000, %rdx # VIDEO_MEMORY

    mov $0x40, %rsi
clear_start:
    cmp $0, %rsi
    je clear_end
    mov $0x0020, %ax
    mov %ax, (%rdx)
    add $2, %rdx
    sub $1, %rsi
    jmp clear_start
clear_end:
    mov $0xb8000, %rdx # VIDEO_MEMORY back to start

    mov $0x6f6c6c6548, %rdi    # "Hello"
    call print_vram

    mov $0x206d6f726620, %rdi  # " from "
    call print_vram

    mov $0x2d3436, %rdi        #  "64-"
    call print_vram

    mov $0x20746962, %rdi      # "bit "
    call print_vram

    mov $0x72656b, %rdi        # "ker"
    call print_vram

    mov $0x6c656e, %rdi        # "nel"
    call print_vram

out:
    hlt
    jmp out

print_vram:
    # string in rdi
print_vram_loop:
    mov %rdi, %rax
    cmp $0, %al
    je print_vram_end

    mov $0x2f, %ah  # add 2f color, green bg, whitw fg
    and $0x0000ffff, %rax
    mov %ax, (%rdx)

    shr $8, %rdi
    add $2, %rdx
    jmp print_vram_loop
print_vram_end:
    ret

64-bit bootloader from scratch in AT&T assembly, Part-5

Jaipal001 — Thu, 05 Feb 2026 10:55:09 +0000

/* GDT */
/* This Data structure is needed for memory
.align 16
gdtp:
    .word gdt_end - gdt_start - 1
    /* .long (0x07C0 << 4) + gdt */
    .long gdt_start

gdt_start:
    .quad 0x0000000000000000    #   Null Descriptor
gdt_code_segment:
    #    Segment limit  Base address
    .word 0xffff,       0x0000
    .byte 0x00        # Base
    # 1st  flags: (present) 1    (privilege)   0                    0         (descriptor type)1 -> 1001b
    # Type flags: (code)    1    (conforming)  0        (readable)  1         (accessed)       0 -> 1010b
    # 10011010
    .byte 0x9a
    # 2nd  flags: (granularity) 1    (32-bit default) 1    (64-bit segment) 0    (available)   0 -> 1100b
    .byte 0xcf
    .byte 0x00        # Base

gdt_data_segment:
    #    Segment limit  Base address
    .word 0xffff,       0x0000
    .byte 0x00        # Base
    # 1st  flags: (present) 1    (privilege)   0                    0         (descriptor type)1 -> 1001b
    # Type flags: (code)    0    (conforming)  0        (readable)  1         (accessed)       0 -> 1010b
    # 10010010
    .byte 0x92
    # 2nd  flags: (granularity) 1    (32-bit default) 1    (64-bit segment) 0    (available)   0 -> 1100b
    .byte 0xcf
    .byte 0x00        # Base

gdt_end:

# Where docs for 64-bit GDT? IDK, just copy it
# 64-bit GDT
.align 16
gdt64:
    .quad 0                      # Null
    .quad 0x00209a0000000000     # Code: L-bit set, D-bit clear
    .quad 0x0000920000000000     # Data
gdt64_ptr:
    .word . - gdt64 - 1
    .quad gdt64                  # 64-bit base

/* IDT */
idt:
    .word 0
    .long 0

# Some messages
running_kernel: .asciz "Trying to run Kernel"
disk_err_msg:   .asciz "Can't load kernel from disk"

KERNEL_OFFSET: .long 0x2000
BOOT_DRIVE:    .byte 0

# This is the end we saw at part 1
.fill 510-(.-_start), 1, 0
.word 0xAA55

64-bit bootloader from scratch in AT&T assembly, Part-4

Jaipal001 — Thu, 05 Feb 2026 10:41:35 +0000

.code64    # 64-bit mode
entry64:
    mov $KERNEL_OFFSET, %rax     # load and run kernel
    call *%rax

print_cli:         # print data into video memory
    mov $0xb8000, %ecx # VIDEO_MEMORY
print_loop_cli:
    # edx = str
    mov $0, %eax
    movb (%edx), %al   # str[i]
    mov $0x0f, %ah    # white fg, black bg
    cmp $0, %al
    je print_end_cli
    mov %ax, (%ecx)
    add $2, %ebx
    add $2, %ecx
    add $1, %edx
    jmp print_loop_cli
print_end_cli:
    ret

println_cli:
    mov $0xb8000, %ecx # VIDEO_MEMORY

    mov $0x0f0a, %eax  # 0f\n
    add %ebx, %ecx
    mov %eax, (%ecx)
    mov $1, %ebx
    ret

64-bit bootloader from scratch in AT&T assembly, Part-3

Jaipal001 — Thu, 05 Feb 2026 10:39:42 +0000

.code32  # 32-bit mode
entry32:
    # Proper 32-bit segment initialization
    movw $(gdt_data_segment - gdt_start), %ax
    movw %ax, %ds
    movw %ax, %es
    movw %ax, %ss

    # 1. Setup Paging Structures
    mov $0x1000, %edi
    mov %edi, %cr3
    xor %eax, %eax
    mov $4096, %ecx
    rep stosl   # idk what this is

    mov %cr3, %edi
    movl $0x2003, (%edi)         # PML4 -> PDPT
    movl $0x3003, 0x1000(%edi)    # PDPT -> PD
    movl $0x00000083, 0x2000(%edi)# PD -> 2MB Huge Page (Identity map 0-2MB)

    # 2. Enable PAE (FIXED)
    mov %cr4, %eax
    or $(1 << 5), %eax
    mov %eax, %cr4               # Write back to register

    # 3. Enable Long Mode via EFER
    mov $0xC0000080, %ecx
    rdmsr
    or $(1 << 8), %eax           # LME Bit
    wrmsr

    # 4. Enable Paging
    mov %cr0, %eax
    or $(1 << 31), %eax          # PG Bit
    mov %eax, %cr0

    # 5. Jump to 64-bit
    lgdt gdt64_ptr
    ljmp $0x08, $entry64         # jump to 64-bit / long mode

64-bit bootloader from scratch in AT&T assembly, Part-2

Jaipal001 — Wed, 04 Feb 2026 09:44:00 +0000

we will continue from disable_int

    cli                 # disables CPU intrupts
    lgdt gdtp          # A data structure to manage memory
    lidt idt           # IDK what does this do but we need it too
                            # All the variables we be defined later

    mov %cr0, %eax    # This works in 16-bit mode!
    or $0x1, %eax     # Modify the 32-bit register
    mov %eax, %cr0    # Write it back

    movw $(gdt_data_segment - gdt_start), %ax  # GDT data segment size, copy to all segments
    movw %ax, %ds
    movw %ax, %es
    movw %ax, %es
    movw %ax, %fs
    movw %ax, %gs
    movw %ax, %ss

    ljmp $(gdt_code_segment - gdt_start), $entry32   # Now we are ready to jump to 32-bit mode

But lets define print and println first as they are called while kernel is being loaded from disk in intrupt mode

It will also be in 16-bit mode that's why we are defining it before going to 32-bit protected mode

print:
    lodsb        # Not explaining, check it: https://www.felixcloutier.com/x86/lods:lodsb:lodsw:lodsd:lodsq

print_loop:
    inb (%dx), %al  # characters, tried `movb` but didn't work
    cmp $0, %al      # check if its null terminator
    je print_end
    mov $0x0e, %ah  # color ig?
    mov $0x07, %bl  # and some config, I forgot
    int $0x10        # write to bios screen
    add $1, %dx      # next letter pointer
    jmp print_loop
print_end:
    ret

println:
    mov $0x0e, %ah
    mov $0xa, %al
    int $0x10
    mov $0x20, %al
    int $0x10
    ret

With this 16-bit mode ends, next will be 32-bit mode where we will load our kernel

64-bit bootloader from scratch in AT&T assembly, Part-1

Jaipal001 — Wed, 04 Feb 2026 09:31:36 +0000

Basic info

I will make multiple parts of it

BIOS bootloaders must be 512 Bytes and end with 55AA bytes to be considered as bootloaders

.code16
.org 0

.text
.global _start

_start:
    # Segment setup
    xor %ax, %ax
    mov %ax, %ds
    mov %ax, %es
    mov %ax, %ss

    # Stack setup
    mov $0x9c00, %bp
    mov %bp, %sp

    # If you don't want kernel, don't do this section from here to disable_int label
    # Load Kernel from Disk
    mov $0x1000, %ax     # Segment 0x1000
    mov %ax, %es         # ES now points to 0x1000
    xor %bx, %bx         # Offset 0
    # Destination is ES:BX -> (0x1000 * 16) + 0 = 0x10000
    mov $2, %ah              # BIOS read sector function
    mov $8, %al              # Number of sectors to read (adjust as needed)
    xor %ch, %ch             # Cylinder 0
    mov $2, %cl              # Sector 2 (Sector 1 is the bootloader)
    xor %dh, %dh             # Head 0
    int $0x13
jc disk_error
    jmp disable_int

disk_error:
    mov $disk_err_msg, %dx
    call print
    call println

disable_int:


.fill 510-(.-_start), 1, 0   # if any space remains, fill with 0
.word 0xAA55

MyLibc

Jaipal001 — Wed, 03 Dec 2025 16:34:40 +0000

Github

I started as me implementing syscalls in assembly
now I am trying to implement musl and stdc++

NOTE:
Btw should I change libmyc.so to something else?

Building

make compile # create build/*.o of src
make shared  # creates lib/libmyc.so
# For C++
make stdcxx  # creates lib/libstdc++.so

Run tests

This is one of the rare occasions when I wrote tests

make test-all # run all test
# For solo test:
make test TEST=(test-name)
# as I will assume tested file is in tests/ folder with .c extension

Compiling your files

# For C
make run your-file.c # run-static for static output
# For C++
make runpp your-file.c # runpp-static for static output

Github

Run non-rooted commands

Jaipal001 — Sun, 19 Oct 2025 08:50:03 +0000

On linux based some commands that you install without root like brew packages and you sometimes need to run them with sudo for that, I made this script

#!/bin/bash

secure_path=("/usr/local/sbin" "/usr/local/bin" "/usr/sbin" "/usr/bin" "/sbin/bin" "/snap/bin") # snap for ubuntu based

if [[ ! $(which $1) ]]; then
    $@  # if does not exist, run them and get error of command not exist and get exit 1
    exit 1 # just in case program moves to next line, exit 1
fi
global_found=
# some would say just do sudo $@ but what if after exitting the app/command, it return a non-0 status? so we better do this
for item in "${secure_path[@]}"; do
    # if found stop
    if [[ $(which $1) == $item/$1 ]]; then
        echo exist $item/$1
        global_found=1
        break
    fi
done
if [[ ! $global_found ]]; then
    sudo -E $(which $1) $(echo $@ | sed 's/'$1' //') # trim 1st argument of our script
else
    sudo $@ # $@ means all bash script arguments
fi

Explaining donut like 5 years old Part-4 (Last)

Jaipal001 — Wed, 11 Dec 2024 15:12:47 +0000

The complete code for C is

#include <math.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

typedef struct {
    double a1;
    double a2;
    double a3;
} singleRow;

typedef struct {
    singleRow a1;
    singleRow a2;
    singleRow a3;
} Matrix;

singleRow multiply(singleRow m1, Matrix m2) {
    singleRow res;
    res.a1 = m1.a1 * m2.a1.a1 + m1.a2 * m2.a2.a1 + m1.a3 * m2.a3.a1;
    res.a2 = m1.a1 * m2.a1.a2 + m1.a2 * m2.a2.a2 + m1.a3 * m2.a3.a2;
    res.a3 = m1.a1 * m2.a1.a3 + m1.a2 * m2.a2.a3 + m1.a3 * m2.a3.a3;
    return res;
}

int main() {
  int screen_width = 80, height = 22;
  char buffer[1760];
  float zBuffer[1760];
  float A = 0, B = 0;
  int R2 = 2, R1 = 1;
  printf("\x1b[2J");
  while (1) {
    memset(buffer, ' ', 1760);
    memset(zBuffer, 0, 7040);
      for (float theta = 0; theta < 6.28; theta += 0.07) {
        for (float phi = 0; phi < 6.28; phi += 0.02) {
          singleRow circle = {2 + cos(theta), sin(theta), 0};
          // rotation on Y-axis
          Matrix Ry = {{cos(phi), 0, sin(phi)}, {0, 1, 0}, {-sin(phi), 0, cos(phi)}};
          // rotation on X-axis
          Matrix Rx = {{1, 0, 0}, {0, cos(A), sin(A)}, {0, -sin(A), cos(A)}};
          // rotation on Z-axis
          Matrix Rz = {{cos(B), sin(B), 0}, {-sin(B), cos(B), 0}, {0, 0, 1}};

          singleRow donut = multiply(circle, Ry);
          singleRow rotateX = multiply(donut, Rx);
          // We will consider it as [Nx, Ny, Nz]
          singleRow spinningDonut = multiply(rotateX, Rz);
          float reciNz = 1 / (spinningDonut.a3 + 5);

          int x = 40 + 30 * spinningDonut.a1 * reciNz;
          int y = 12 + 15 * spinningDonut.a2 * reciNz;

          // o is index of current buffer
          int o = x + screen_width * y;

          int L = 8 * (spinningDonut.a2 - spinningDonut.a3 + 2 * cos(B) * sin(A) * sin(phi)
            - 2 * cos(phi) * cos(theta) * sin(B)
            - 2 * cos(phi) * sin(B)
            + 2 * cos(A) * sin(phi)
          );

          // donut luminicity will be seen by these characters
          // these 12
          char charOut[] = ".,-~:;=!*#$@";

          if (x < screen_width && y < height && zBuffer[o] < reciNz) {
            zBuffer[o] = reciNz;
            // If L < 0, . will be buffer
            buffer[o] = charOut[L > 0 ? L : 0];
          }
        }
      }
    // Clear screen
    printf("\x1b[H");
    for (int i = 0; i <1761; i++) {
      // On every 80th character, new line will be printed
      // If there's a reminder then buffer printed
      putchar(i % 80 ? buffer[i] : 10);
      A += 0.00004;
      B += 0.00002;
    }
    // Timer to slow down speed a bit
    usleep(10000);
  }
  return 0;
}

The complete code for Java is

import java.util.Arrays;

class singleRow {
  public double a1;
  public double a2;
  public double a3;
  public singleRow(double a1, double a2, double a3) {
    this.a1 = a1;
    this.a2 = a2;
    this.a3 = a3;
  }
}
class Matrix {
  public singleRow a1;
  public singleRow a2;
  public singleRow a3;
  public Matrix(singleRow a1, singleRow a2, singleRow a3) {
    this.a1 = new singleRow(a1.a1, a1.a2, a1.a3);
    this.a2 = new singleRow(a2.a1, a2.a2, a2.a3);
    this.a3 = new singleRow(a3.a1, a3.a2, a3.a3);
  }
  public static singleRow multiply(singleRow m1, Matrix m2) {
    singleRow res = new singleRow(0, 0, 0);
    res.a1 = (m1.a1 * m2.a1.a1) + (m1.a2 * m2.a2.a1) + (m1.a3 * m2.a3.a1);
    res.a2 = (m1.a1 * m2.a1.a2) + (m1.a2 * m2.a2.a2) + (m1.a3 * m2.a3.a2);
    res.a3 = (m1.a1 * m2.a1.a3) + (m1.a2 * m2.a2.a3) + (m1.a3 * m2.a3.a3);
    return res;
  }
}


public class Main {
public static void main() {
  int screen_width = 80, height = 22;
  char[] buffer = new char[1760];
  double[] zBuffer = new double[1760];
  double A = 0, B = 0;
  int R2 = 2, R1 = 1;
  System.out.print("\u001b[2J");
  while (true) {
    Arrays.fill(buffer, 0, 1760, ' ');
    Arrays.fill(zBuffer, 0, 1760, 0);
      for (float theta = 0; theta < 6.28; theta += 0.07) {
        for (float phi = 0; phi < 6.28; phi += 0.02) {
          singleRow circle = {2 + Math.cos(theta), Math.sin(theta), 0};
          // rotation on Y-axis
          Matrix Ry = new Matrix(
          new singleRow(Math.cos(phi), 0, Math.sin(phi)),
          new singleRow(0, 1, 0),
          new singleRow(-Math.sin(phi), 0, Math.cos(phi))
        );
        // rotation on X-axis
        Matrix Rx = new Matrix(
          new singleRow(1, 0, 0),
          new singleRow(0, Math.cos(A), Math.sin(A)),
          new singleRow(0, -Math.sin(A), Math.cos(A))
        );
        // rotation on Z-axis
        Matrix Rz = new Matrix(
          new singleRow(Math.cos(B), Math.sin(B), 0),
          new singleRow(-Math.sin(B), Math.cos(B), 0),
          new singleRow(0, 0, 1)
        );

          singleRow donut = Matrix.multiply(circle, Ry);
          singleRow rotateX = Matrix.multiply(donut, Rx);
          // We will consider it as [Nx, Ny, Nz]
          singleRow spinningDonut = Matrix.multiply(rotateX, Rz);
          float reciNz = 1 / (spinningDonut.a3 + 5);

          int x = 40 + 30 * spinningDonut.a1 * reciNz;
          int y = 12 + 15 * spinningDonut.a2 * reciNz;

          // o is index of current buffer
          int o = x + screen_width * y;

          int L = 8 * (spinningDonut.a2 - spinningDonut.a3 
            + 2 * Math.cos(B) * Math.sin(A) * Math.sin(phi)
            - 2 * Math.cos(phi) * Math.cos(theta) * Math.sin(B)
            - 2 * Math.cos(phi) * Math.sin(B)
            + 2 * Math.cos(A) * Math.sin(phi)
          );

          // donut luminicity will be seen by these characters
          // these 12
          char[] charOpts = {'.', ',', '-', '~', ':', ';', '=', '!', '*', '#', '$', '@'};

          if (x < screen_width && y < height && zBuffer[o] < reciNz) {
            zBuffer[o] = reciNz;
            // If L < 0, . will be buffer
            buffer[o] = charOut[L > 0 ? L : 0];
          }
        }
      }
    // Clear screen
    System.out.print("\u001b[H");
    for (int i = 0; i <1761; i++) {
      // On every 80th character, new line will be printed
      // If there's a reminder then buffer printed
      System.out.print(i % 80 ? buffer[i] : 10);
      A += 0.00004;
      B += 0.00002;
    }
  }
}
}