Cosmos (operating system)

Toolkit for building GUI and command-line based operating systems

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed.
Find sources: "Cosmos" operating system – news · newspapers · books · scholar · JSTOR (May 2023) (Learn how and when to remove this message)

|

Not to be confused with Cosmos, the operating system running on the Ai Pin device by Humane Inc..

Operating system

Cosmos

Screenshot of an OS made with Cosmos, AuraOS, presenting a GUI creation possibility

Developer| Cosmos Project
Written in| C#, X#
Working state| Active
Source model| Open source
Latest release| Release 20221121 / 21 November 2022; 2 years ago (2022-11-21)
Repository| github.com/CosmosOS
Available in| English
Platforms| x86
Kernel type| Monolithic
License| BSD
Official website| www.gocosmos.org

C# Open Source Managed Operating System (Cosmos) is a toolkit for building GUI and command-line based operating systems, written mostly in the programming language C# and small amounts of a high-level assembly language named X#. Cosmos is a backronym,[1] in that the acronym was chosen before the meaning. It is open-source software released under a BSD license.

As of 2022[update], Cosmos encompasses an ahead-of-time (AOT) compiler named IL2CPU to translate Common Intermediate Language (CIL) into native instructions. Cosmos compiles user-made programs and associated libraries using IL2CPU to create a bootable native executable that can run independently. The resulting output can be booted from a USB flash drive, CD-ROM, over a network via Preboot Execution Environment (PXE), or inside a virtual machine. Recent releases also allow deploying to certain x86 embedded devices over Universal Serial Bus (USB). While C# is the primary language used by developers (both on the backend and by end users of Cosmos), many CLI languages can be used, provided they compile to pure CIL without the use of Platform Invocation Services (P/Invokes). Cosmos is mainly intended for use with .NET.

Cosmos does not aim to become a full operating system, but rather a toolkit to allow other developers to simply and easily build their own operating systems using .NET. It also functions as an abstraction layer, hiding much of the inner workings of the hardware from the eventual developer.

Older versions of Cosmos were released in Milestones, with the last being Milestone 5 (released August 2010). More recently, the project switched to simply naming new releases after the latest commit number.

Releases of Cosmos are divided into two types: the Userkit, and the Devkit. The Userkit is a pre-packaged release that is updated irregularly, as new and improved features are added. Userkits are generally considered stable, but do not include recent changes and may lack features. The Devkits, which refers to the source code of Cosmos, are usually stable but may have some bugs. They can be acquired on GitHub and must be built manually.[1] Git is used for source control management.

Most work on Cosmos is currently aimed at improving debugger functionality and Microsoft Visual Studio integration. Kernel work is focused on implementing file systems, memory management, and developing a reliable network interface. Limine serves as the project's bootloader; in older versions of the toolkit, GRUB was used instead.[2]

## Origin

[edit]

The idea for Cosmos was created by Chad Hower and was initially co-developed by Hower and Matthijs ter Woord. Over time, Cosmos has been maintained and improved by many other individuals.

## Developing with Cosmos

[edit]

Cosmos has many facilities to improve the experience of developing operating systems, and is designed to make the process as fast and painless as possible. Knowledge of assembly language is not required to use Cosmos.

### Visual Studio integration

[edit]

A key feature of Cosmos, which separates it from other operating systems of its type, is its tight integration with Microsoft Visual Studio. Code can be written, compiled, debugged, and run entirely through Visual Studio, with only a few keypresses. Cosmos no longer supports Visual Studio 2015, Visual Studio 2017, or Visual Studio 2019, only supporting Visual Studio 2022.

### Debugging

[edit]

Cosmos can be seamlessly debugged through Visual Studio when running over PXE or in a virtual machine. Many standard debugging features are present, such as breakpoints, tracing, and logging. Also, debugging can be done via serial cables, if running on physical hardware. When running in VMWare, Cosmos supports stepping and breakpoints, even while an operating system is running.

### Running

[edit]

Cosmos uses virtualisation to help speed development by allowing developers to test their operating systems without having to restart their computers as often. By default, VMware Player is used, due to its ease of use in terms of integration with the project. Other virtualisation environments are supported as well, such as Bochs and Hyper-V. An ISO disk image may also be generated that can be burned to a USB flash drive, CD-ROM, or similar media.

PXE booting is also supported, allowing for remote machines to run Cosmos over a network connection.

## Compile process

[edit]

This section contains promotional content. Please help improve it by removing promotional language and inappropriate external links, and by adding encyclopedic text written from a neutral point of view. (August 2023) (Learn how and when to remove this message)

|

### IL2CPU

[edit]

To compile .NET CIL into assembly language, Cosmos developers created an ahead-of-time compiler named IL2CPU, designed to parse CIL and output x86 opcodes. (IL To CPU) is an AOT compiler that is written using a Common Intermediate Language compliant language (C#). It translates Common Intermediate Language to machine code.

### X#

[edit]

X# is a low-level programming language designed for the x86 processor architecture as part of Cosmos operating system. It aims to simplify operating system development by incorporating C-like language syntax to assembly language. Initially, X# was used for debugging services in Cosmos. The X# compiler is an open source command-line interface (console) program that parses code lines into tokens, compares them with patterns, and translates matched patterns to intel syntax x86 assembly, typically for the YASM assembler. Early versions of X# operated mostly 1:1 with assembly code, but this is no longer the case.[clarification needed]

#### Syntax

[edit]

The syntax of X# is straightforward but stricter compared to C.

#### Comments

[edit]

X# supports only single-line comments in the C++ style, starting with - `//`.

#### Constants

[edit]

X# allows the definition of named constants declared outside functions. Numeric constants are defined similarly to C++; for example:

const i = 0

. Referencing them elsewhere requires a `#` before the name; for example: - `"#i"`.

* String constant use single quotes (`''`). To include a single quote in a string constant, use a backslash (e.g.,`'I\'m so happy').` X# strings are null terminated.
* Hexadecimal constants are prefixed with a dollar sign (`$`), followed by the constant. (`$B8000`).
* Decimal constants are not prefixed but cannot start with `0`.
* Binary and octal constants aren't supported yet.

#### Labels

[edit]

Labels in X# function similarly to labels in other assembly languages. The `goto` mnemonic is used to jump to a label instead of the conventional `jump` or `jmp` mnemonic.

CodeLabel1:
goto CodeLabel2:

#### Namespaces

[edit]

X# program files must start with a namespace directive. X# lacks a namespace hierarchy, so the current namespace changes with each directive until the file ends. Variables or constants in different namespaces can have the same name, as the namespace is prefixed to the member's name in the assembly output. Namespaces cannot reference each other except through low-level operations.

namespace FIRST
// Everything variable or constant name will be prefixed with FIRST and an underscore. Hence the true full name of the below variable
// is FIRST_aVar.
var aVar

namespace SECOND
// It's not a problem to name another variable aVar. Its true name is SECOND_aVar.
var aVar

namespace FIRST
// This code is now back to the FIRST namespace until the file ends.

#### Functions

[edit]

All X# executive code should be placed in functions defined by the 'function' keyword. Unlike C, X# does not support any formal parameter declaration in the header of the functions, so the conventional parentheses after the function name are omitted. Because line-fixed patterns are specified in syntax implemented in code parser, the opening curly bracket can't be placed on the next line, unlike in many other C-style languages.

function xSharpFunction {
// function code

Because X# is a low-level language, there are no stack frames inserted, so by default, the return EIP address should be on the top of the stack. X# function calls do contain arguments enclosed in parentheses, unlike in function headers. Arguments passed to functions can be registers, addresses, or constants. These arguments are pushed onto the stack in reverse order. Note that the stack on x86 platforms cannot push or pop one-byte registers.

function xSharpFunction {
EAX = $10
anotherFunction(EAX);
return

function anotherFunction {
//function code

The `return` keyword returns execution to the return EIP address saved in the stack.

#### Arithmetic and bitwise operations

[edit]

X# can work with three low-level data structures: the registers, the stack and the memory, on different ports. The registers are the base of all normal operations for X#. A register can be copied to another by writing `DST = SRC` as opposed to `mov` or load/store instructions. Registers can be incremented or decremented just as easily. Arithmetic operations (add, subtract, multiply, divide) are written as `dest op src` where `src` is a constant, variable, or register, and `dest` is both an operand and the location where the result is stored.

Examples of assignment and arithmetic operations are shown below.

ESI = 12345              // assign 12345 to ESI
EDX = #constantForEDX    // assign #ConstantForEDX to EDX
EAX = EBX                // move EBX to EAX              => mov eax, ebx
EAX--                    // decrement EAX                => dec eax
EAX++                    // increment EAX                => inc eax
EAX + 2                  // add 2 to eax                 => add eax, 2
EAX - $80                // subtract 0x80 from eax       => sub eax, 0x80
BX * CX                  // multiply BX by CX            => mul cx      -- division, multiplication and modulo should preserve registers
CX / BX                  // divide CX by BX              => div bx
CX mod BX                // remainder of CX/BX to BX     => div bx

Register shifting and rolling is similar to C.

DX << 10  // shift left by 10 bits
CX >> 8   // shift right by 8 bits
EAX <~ 6  // rotate left by 6 bits
EAX ~> 4  // rotate right by 4 bits

Other bitwise operations are similar to arithmetic operations.

DL & $08     // perform bitwise AND on DL with 0x08 and store the result in DL
CX | 1       // set the lowest bit of CX to 1 (make it odd)
EAX = ~ECX   // perform bitwise NOT on ECX and store the result in EAX
EAX ^ EAX    // erase EAX by XORing it with itself

#### Stack

[edit]

Stack manipulation in X# is performed using `+` and `-` prefixes, where `+` pushes a register, value, constant or all registers onto the stack and `-` pops a value to some register. All constants are pushed on stack as double words, unless stated otherwise (pushing single bytes is not supported).

+ESI                   // push esi
-EDI                   // pop into edi
+All                   // save all registers   => pushad
-All                   // load all registers   => popad
+$1badboo2             // push 0x1badboo2 on the stack
+$cafe as word         //          \/
+$babe as word         // push 0xcafebabe
+#VideoMemory          // push value of constant VideoMemory

#### Variables

[edit]

Variables are defined within namespaces using the `var` keyword. Arrays are defined by specifying the type and size. Variables and arrays are zeroed by default. To reference a variable's value, use a dot ('.'), and to reference its address, use `@`.

namespace XSharpVariables
var zeroVar                      // variable will be assigned zero
var myVar1 = $f000beef           // variable will be assigned 0xf000beef
var someString = 'Hello XSharp!' // variable will be assigned 'Hello XSharp!\0',
var buffer byte[1024]            // variable of size 1024 bytes will be assigned 1024 zero bytes
...
EAX = .myVar1                    // moves value of myVar1 (0xf000beef) to EAX
ESI = @.someString               // moves address of someString to ESI
CL = .someString                 // moves first character of someString ('H') to CL
.zeroVar = EAX                   // assigns zeroVar to value of EAX

X# can access an address with a specified offset using square brackets:

var someString = 'Hello XSharp!' //variable will be assigned to 'Hello XSharp!\0'
...
ESI = @.someString       // load address of someString to ESI
CL = 'B'                 // set CL to 'B' (rewrite 'H' on the start)
CH = ESI[1]              // move second character ('E') from string to CH
ESI[4] = $00             // end string
//Value of someString will be 'Bell' (or 'Bell\0 XSharp!\0')

#### Comparison

[edit]

There are two ways to compare values in X#: pure comparison and if-comparison.

* Pure comparison leaves the result in FLAGS, which can be used in native assembly or with the `if` keyword without specifying comparison members.
* If comparison directly compares two members after an `if` keyword.

Here are two ways of writing a (slow) X# string length (`strlen`)function:

// Method 1: using pure comparison
function strlen {
ESI = ESP[4] // get pointer to string passed as first argument
ECX ^ ECX    // clear ECX
Loop:
AL = ESI[ECX]// get next character
AL ?= 0      // is it 0? save to FLAGS
if = return  // if ZF is set, return
ECX++        // else increment ECX
goto Loop    // loop...

//Way 2: using if
function strlen {
ESI = ESP[4]    // get pointer to string passed as first argument
ECX ^ ECX       // clear ECX
Loop:
AL = ESI[ECX]
if AL = 0 return// AL = 0? return
ECX++
goto Loop       // loop....

There are six available comparison operators: `< > = <= >= !=`. These operators can be used in both comparisons and loops. Note that there's also a bitwise AND operator which tests bits:

AL ?& $80      // test AL MSB
if = return    // if ZF is 0, test instruction resulted in 0 and MSB is not set.

## Writing Cosmos code

[edit]

An operating system built with Cosmos is developed in a similar fashion to any .NET C# console program. Additional references are made in the start of the program which give access to the Cosmos libraries.

### User Kit and Visual Studio

[edit]

The Cosmos User Kit is a part of Cosmos designed to make Cosmos easier to use for developers using Microsoft Visual Studio. When installed, the user kit adds a new project type to Visual Studio, called a Cosmos Project. This is a modified version of a console application, with the Cosmos compiler and bootup stub code already added.

## Compiling a project

[edit]

Once the code is complete, it may be compiled using Roslyn, the .NET compiler, either via Microsoft Visual Studio or the .NET command-line tools (dotnet).

This converts the application from the original source code (C# or otherwise) into Common Intermediate Language (CIL), the native intermediate language of .NET.

The build process then invokes the IL2CPU compiler which systematically scans through all of the application's CIL code (excluding the Cosmos compiler code), converting it into assembly language for the selected processor architecture. As of 2022[update], only the x86 architecture is supported. Next, Cosmos invokes the selected assembler to convert this assembly language code into native central processing unit (CPU) opcode. Finally, the desired output option is activated, be it starting a virtual machine, starting a PXE engine, or producing an ISO disk image file.

### Debug options

[edit]

Cosmos offers several options as to how to deploy the resulting OS and how to debug the output.

#### Virtualization

[edit]

The default Cosmos template as seen in QEMU.

Cosmos allows users to boot the operating system in an emulated environment using a virtual machine. This lets developers test the system on their own computer without having to reboot, giving the advantages of not requiring extra hardware or that developers exit their integrated development environment (IDE). VMware is the primary virtualisation method, however others are supported such as QEMU and Hyper-V.

#### Disk images

[edit]

This option writes the operating system to a disk image (ISO image) file, which can be loaded into some emulators (such as Bochs, QEMU or more commonly VMware) or written to a USB flash drive and booted on physical hardware.

#### PXE network boot

[edit]

This option allows the operating system to boot on physical hardware. The data is sent via a local area network (LAN) to the client machine. This requires two computers: one as the client machine (on which the OS is booted) and one as the server (usually the development machine). It also requires a network connecting the two computers, a client machine with a network card, and a Basic Input/Output System (BIOS) that can boot with PXE. As of 2022[update], debugging over a network is no longer supported.

## See also

[edit]

* Free and open-source software portal

* IL2CPU
* .NET
* SharpOS
* Singularity (operating system)
* Phantom OS

## References

[edit]

1. ^ a b Cosmos website: project repository at GitHub
2. ^ "Change bootloader to Limine · Pull Request #2521 · CosmosOS/Cosmos · GitHub". GitHub.

## External links

[edit]

Wikimedia Commons has media related to Cosmos (operating system).

* Official website
* CosmosOS on GitHub
* Cosmos Overview article at CodeProject
* Cosmos Dev Yahoo Group Archived 2011-01-08 at the Wayback Machine
* Cosmos Fan Page on Facebook

### News coverage

[edit]

* Mary Jo Foley on ZDNet - Cosmos: An open-source .Net-based microkernel OS is born
* Scott Hanselman: Tiny Managed Operating System Edition

* v
* t
* e

Operating systems

General|

* Comparison
* Forensic engineering
* History
* List
* Timeline
* Usage share
* User features comparison

Variants|

* Disk operating system
* Distributed operating system
* Embedded operating system
* Hobbyist operating system
* Just enough operating system
* Mobile operating system
* Network operating system
* Object-oriented operating system
* Real-time operating system
* Supercomputer operating system

Kernel|

| Architectures|

* Exokernel
* Hybrid
* Microkernel
* Monolithic
* Multikernel
* vkernel
* Rump kernel
* Unikernel

|

Components|

* Device driver
* Loadable kernel module
* User space and kernel space

Process management|

| Concepts|

* Computer multitasking (Cooperative, Preemptive)
* Context switch
* Interrupt
* IPC
* Process
* Process control block
* Real-time
* Thread
* Time-sharing

|

Scheduling
algorithms|

* Fixed-priority preemptive
* Multilevel feedback queue
* Round-robin
* Shortest job next

Memory management,
resource protection|

* Bus error
* General protection fault
* Memory paging
* Memory protection
* Protection ring
* Segmentation fault
* Virtual memory

Storage access,
file systems|

* Boot loader
* Defragmentation
* Device file
* File attribute
* Inode
* Journal
* Partition
* Virtual file system
* Virtual tape library

Supporting concepts|

* API
* Computer network
* HAL
* Live CD
* Live USB
* Shell
* CLI
* User interface
* PXE

*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template