unikraft / dynamic-apps

Pre-built Dynamic Linux ELFs

The fast, secure and open-source
Unikernel Development Kit

Unikraft powers the next-generation of cloud native, containerless applications by enabling you to radically customize and build custom OS/kernels; unlocking best-in-class performance, security primitives and efficiency savings.

Homepage · Documentation · Report Bug · Feature Request · Join Our Discord · X.com

Features

• Instantaneous Cold-boots ⚡

  • While Linux-based systems might take tens of seconds to boot, Unikraft will be up in milliseconds.

• Modular Design 🧩

  • Unikraft boasts a modular design approach, allowing developers to include only necessary components, resulting in leaner and more efficient operating system configurations.

• Optimized for Performance 🚀

  • Built for performance, Unikraft minimizes overheads and leverages platform-specific optimizations, ensuring applications achieve peak performance levels.

• Flexible Architecture Support 💻

  • With support for multiple hardware architectures including x86, ARM, (and soon RISC-V), Unikraft offers flexibility in deployment across diverse hardware platforms.

• Broad Language and Application Support 📚

  • Unikraft offers extensive support for multiple programming languages and hardware architectures, providing developers with the flexibility to choose the tools and platforms that best suit your needs.

• Cloud and Edge Compatibility ☁️

  • Designed for cloud and edge computing environments, Unikraft enables seamless deployment of applications across distributed computing infrastructures.

• Reduced Attack Surface 🛡️

  • By selectively including only necessary components, Unikraft reduces the attack surface, enhancing security in deployment scenarios. Unikraft also includes many additional modern security features.

• Developer Friendly 🛠️

  • Unikraft's intuitive toolchain and user-friendly interface simplify the development process, allowing developers to focus on building innovative solutions.

• Efficient Resource Utilization 🪶

  • Unikraft optimizes resource utilization, leading to smaller footprints (meaning higher server saturation) and improved efficiency in resource-constrained environments.

• Community-Driven Development 👥

  • Unikraft is an open-source project driven by a vibrant community of over 100 developers, fostering collaboration and innovation from industry and academia.

Quick Start

Install the companion command-line client kraft:

# Install on macOS, Linux, and Windows:
curl -sSfL https://get.kraftkit.sh | sh

See additional installation instructions.

Run your first ultra-lightweight unikernel virtual machine:

kraft run unikraft.org/helloworld:latest

View its status and manage multiple instances:

kraft ps --all

View the community image catalog in your CLI for more apps:

kraft pkg ls --update --apps

Or browse through one of the many starter example projects.

Why Unikraft?

Unikraft is a radical, yet Linux-compatible with effortless tooling, technology for running applications as highly optimized, lightweight and single-purpose virtual machines (known as unikernels).

In today's computing landscape, efficiency is paramount. Unikraft addresses this need with its modular design, enabling developers to create customized, lightweight operating systems tailored to specific application requirements. By trimming excess overhead and minimizing attack surfaces, Unikraft enhances security and performance in cloud and edge computing environments.

Unikraft's focus on optimization ensures that applications run smoothly, leveraging platform-specific optimizations to maximize efficiency. With support for various hardware architectures and programming languages, Unikraft offers flexibility without compromising performance. In a world where resources are precious, Unikraft provides a pragmatic solution for streamlined, high-performance computing.

Getting Started

There are two ways to get started with Unikraft:

1. (Recommended) Using the companion command-line tool kraft (covered below).

2. Using the GNU Make-based system. For this, see our advanced usage guide.

Toolchain Installation

You can install the companion command-line client kraft by using the interactive installer:

# Install on macOS, Linux, and Windows:
curl -sSfL https://get.kraftkit.sh | sh

macOS

brew install unikraft/cli/kraftkit

Debian/Fedora/RHEL/Arch/Windows

Use the interactive installer or see additional installation instructions.

Codespaces

Try out one of the examples in GitHub Codespaces:

Container Build Environment

You can use the pre-built development container environment which has all dependencies necessary for building and trying out Unikraft in emulation mode.

Attach your working directory on your host as a mount path volume mapped to /workspace, e.g.:

docker run --platform linux/x86_64 -it --rm -v $(pwd):/workspace --entrypoint bash kraftkit.sh/base:latest

The above command will drop you into a container shell. Type exit or Ctrl+D to quit.

Testing your Installation

Running unikernels with kraft is designed to be simple and familiar. To test your installation of kraft, you can run the following:

kraft run unikraft.org/helloworld:latest

Build your first unikernel

Building unikernels is also designed to be straightforward. Build your first unikernel by simply placing a Kraftfile into your repo and pointing it to your existing Dockerfile:

spec: v0.6

runtime: base:latest

rootfs: ./Dockerfile

cmd: ["/path/to/my-server-app"]

Learn more about the syntax of a Kraftfile.

Once done, invoke in the context of your working directory:

kraft run .

Example Projects and Pre-built Images

You can find some common project examples below:

	Example
	Simple "Hello, world!" application written in C
	Simple "Hello, world!" application written in C++
	Simple "Hello, world!" application written in Rust built via cargo
	Simple NodeJS 18 HTTP Web Server with http
	Simple Go 1.21 HTTP Web Server with net/http
	Simple Flask 3.0 HTTP Web Server
	Simple Python 3.10 HTTP Web Server with http.server.HTTPServer

Find more examples and applications in our community catalog!

Cloud Deployment

The creators of Unikraft have built KraftCloud: a next generation cloud platform powered by technology intended to work in millisecond timescales.

✅	Millisecond Scale-to-Zero	✅	Millisecond Autoscale	✅	Millisecond Cold Boots
✅	Higher Throughput	✅	Much Lower Cloud Bill	✅	HW-Level Isolation
✅	On-Prem or Cloud-Prem	✅	Works with Docker & K8s	✅	Terraform Integration

Sign-up for the beta ↗

Contributing

Unikraft is open-source and licensed under BSD-3-Clause and the copyright of its authors. If you would like to contribute:

1. Read the Developer Certificate of Origin Version 1.1.
2. Sign-off commits as described in the Developer Certificate of Origin Version 1.1.
3. Grant copyright as detailed in the license header.

This ensures that users, distributors, and other contributors can rely on all the software related to Unikraft being contributed under the terms of the License. No contributions will be accepted without following this process.

Afterwards, navigate to the contributing guide to get started. See also Unikraft's coding conventions.

Additional resources

• Quick-start guide
• What is a unikernel?
• Unikraft's inherent security benefits
• Performance of Unikraft
• POSIX-compatibility with Unikraft
• Energy efficiency with Unikraft
• Unikraft Community
• Unikraft Documentation

License

Unikraft Open-Source Project source code and its affiliated projects source code is licensed under a BSD-3-Clause if not otherwise stated. For more information, please refer to COPYING.md.

Affiliation

Unikraft is a member of the Linux Foundation and is a Xen Project Incubator Project. The Unikraft name, logo and its mascot are trademark of Unikraft GmbH.

   

dynamic-apps's Issues

Add `NATS` dynamic application build from source

Add the NATS applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

Add `CouchDB` dynamic application build from source

Add the CouchDB applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

Add `Cassandra` dynamic application build

Add the Cassandra applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Add `Maven` dynamic application build

Add the Maven applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Add `NATS` dynamic application build

Add the NATS applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Haproxy doesn't run (the given binary isn't position-independent)

Trying to run haproxy using sudo ./run_app.sh haproxy in run-app-elfloader gives the following error:

[    0.162959] ERR:  [appelfloader] <elf_load.c @  135> haproxy: ELF executable is not position-independent!
[    0.164375] ERR:  [appelfloader] <elf_load.c @  703> haproxy: Parsing of ELF image failed: Exec format error (-8)

This is a sign that the bundled haproxy
binary isn't position-independent and probably needs to be changed.

Add `Tomcat` dynamic application build from source

Add the Tomcat applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

openssl not PIE

openssl sample app in openssl/bin/openssl is not position independant.

Add `Fortran` dynamic application build

Add the Fortran applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Shared library paths are host OS dependent

I tried running various dynamic apps using the do.sh script in qemu on my Arch system but get errors that the needed libraries cannot be located.

Example
running ./do.sh run bc will yield the following failing syscalls:

access("/etc/ld.so.preload", R_OK) = No such file or directory (-2)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = No such file or directory (-2)
openat(AT_FDCWD, "/usr/lib/glibc-hwcaps/x86-64-v2/libreadline.so.7", O_RDONLY|O_CLOEXEC) = No such file or directory (-2)
newfstatat(0xffffff9c, 0x47f92ee80, ...) = No such file or directory (-2)
openat(AT_FDCWD, "/usr/lib/libreadline.so.7", O_RDONLY|O_CLOEXEC) = No such file or directory (-2)
newfstatat(0xffffff9c, 0x47f92ee80, ...) = No such file or directory (-2)
/usr/bin/bc: error while loading shared libraries: libreadline.so.7: cannot open shared object file: No such file or directory

Problem
The loader uses the search paths of my Arch system to look for libs while the structure of the libs that are provided here and which is also mounted in qemu corresponds to what you would find in Ubuntu.

Possible solution
Provide the loader running in qemu with the correct search path to find the binaries provided in this repo.

Add `FFmpeg` dynamic application build

Add the FFmpeg applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Add `vault` dynamic application build from source

Add the vault applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Note that vault seems to come as a static-pie ELF when installing it on a Linux machine, so extra steps might be required in the building step do compile it as a dynamically linked executable (if possible).

Hackathon points: 40

Add `Apache httpd` dynamic application build

Add the Apache httpd applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Add `Lua` dynamic application build

Add the Lua applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Add `GnuPG` dynamic application build

Add the GnuPG applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Add `Traefik` dynamic application build from sourc

Add the Traefik applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

Add `iputils` dynamic application build

Add the iputils applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Add `Apache httpd` dynamic application build from source

Add the Apache httpd applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

Add `CouchDB` dynamic application build

Add the CouchDB applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

busybox netcat not working properly

I tried to run netcat binary using the bincompat mode and run-app-elfloader, but it does not properly send or receive messages. Then, I tried to run the nc command in the busybox binary provided in the dynamic apps repository but that had the same issue.

I run this to start a netcat server in unikraft:

sudo ./run.sh -n -r ../dynamic-apps/busybox/ /bin/busybox nc -lp 12345

Then I run this in the host OS to connect to it:

nc 172.44.0.2 12345

However, when I type messages into any of these, it can be seen that no message is transferred from the client (host) to the server (unikraft VM) and only the first message that is entered in the server (unikraft) is transferred to the host os and the rest of them are not transferred.

Add `Traefik` dynamic application build

Add the Traekif applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Add `iputils` dynamic application build from source

Add the iputils applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

Add `RbbitMQ` dynamic application build from source

Add the RabbitMQ applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

Add `Cassandra` dynamic application build from source

Add the Cassandra applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

Add `Fortran` dynamic application build from source

Add the Fortran applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

FPM ELF Dynamic Executable displaying Error

I was trying to solve Issue #44 but found this error-

SeaBIOS (version 1.16.1-3.fc38)
Booting from ROM..Powered by
o.   .o       _ _               __ _
Oo   Oo  ___ (_) | __ __  __ _ ' _) :_
oO   oO ' _ `| | |/ /  _)' _` | |_|  _)
oOo oOO| | | | |   (| | | (_) |  _) :_
 OoOoO ._, ._:_:_,\_._,  .__,_:_, \___)
      Prometheus 0.14.0~4cce8306-custom
[    0.153581] ERR:  [appelfloader] <elf_load.c @  135> fpm: ELF executable is not position-independent!
[    0.179544] ERR:  [appelfloader] <elf_load.c @  703> fpm: Parsing of ELF image failed: Exec format error (-8)

Steps to reproduce the error:

• Make sure you have all the dependencies installed like gcc-gfortran to run FPM.

• Build the Fortran package manager from the source by following the commands-

  • git clone https://github.com/fortran-lang/fpm

  • cd fpm

  • chmod +x install.sh

  • ./install.sh --prefix=/usr

• Go to dynamic-apps repo and then create a folder fpm and inside that run sudo ../extract.sh /usr/bin/fpm
cp /usr/bin/fpm .

• Go to the run-app-elfloader repository and use the run.sh script to run the application we just prepared:
  sudo ./run.sh -r ../dynamic-apps/fpm/ /bin/fpm --help

I tried running it on Linux and it runs as expected without any errors.
Run on Linux: /usr/bin/fpm --help

NAME
   fpm(1) - A Fortran package manager and build system

SYNOPSIS
   fpm SUBCOMMAND [SUBCOMMAND_OPTIONS]

   fpm --help|--version|--list

DESCRIPTION
   fpm(1) is a package manager that helps you create Fortran projects
   from source -- it automatically determines dependencies!

   Most significantly fpm(1) lets you draw upon other fpm(1) packages
   in distributed git(1) repositories as if the packages were a basic
   part of your default programming environment, as well as letting
   you share your projects with others in a similar manner.

   All output goes into the directory "build/" which can generally be
   removed and rebuilt if required. Note that if external packages are
   being used you need network connectivity to rebuild from scratch.

SUBCOMMANDS
  Valid fpm(1) subcommands are:

  + build    Compile the packages into the "build/" directory.
  + new      Create a new Fortran package directory with sample files.
  + update   Update the project dependencies.
  + run      Run the local package binaries. Defaults to all binaries

Add `vault` dynamic application build

Add the vault applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Add `Tomcat` dynamic application build

Add the Tomcat applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

Add `RabbitMQ` dynamic application build

Add the RabbitMQ applications as a dynamic build.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc.
• Use apt download to download the package(s) (.deb)
• Extract the executable, configuration and data files required to run the application.
• Update the configuration file, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to collect the necessary shared libraries:
• Now profit. Use app-elfloader.

Hackathon points: 20

NodeJS hang on user input

I was working on adding node and gnupg to run.yaml with this commit unikraft/app-elfloader#33 where I run into the problem: NodeJS is able to launch and start the shell, but it hangs on user input.
The -enable-kvm -cpu host script patch is used

By hang: the shell appeared as

Booting from ROM..1: Set IPv4 address 172.44.0.2 mask 255.255.255.0 gw 172.44.0.1
en1: Added
en1: Interface is up
Powered by
o.   .o       _ _               __ _
Oo   Oo  ___ (_) | __ __  __ _ ' _) :_
oO   oO ' _ `| | |/ /  _)' _` | |_|  _)
oOo oOO| | | | |   (| | | (_) |  _) :_
 OoOoO ._, ._:_:_,\_._,  .__,_:_, \___)
             Prometheus 0.14.0~018fe1a4
Welcome to Node.js v18.15.0.
Type ".help" for more information.
> 
Error: Could not get the home directory.
REPL session history will not be persisted.
> 

But not responding to any user input

run.yaml used:

  - name: node
    rootfs: ../dynamic-apps/node
    command: /bin/node
    memory: 512
    networking: True

Command used:
./scripts/build/make-qemu-x86_64-9pfs.sh
./scripts/run/qemu-x86_64-9pfs-node.sh

Add `GnuPG` dynamic application build from source

Add the GnuPG applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

Add `Lua` dynamic application build from source

Add the Lua applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

Add `FFmpeg` dynamic application build from source

Add the FFmpeg applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40

Add `Maven` dynamic application build from source

Add the Maven applications as a dynamic build, from the application source files.
Test it using app-elfloader.
If any problems appear, open issues on the Unikraft core repository.

The typical process of adding apps to the dynamic-apps repository, built from the source files, is:

• Create the app directory that will store: the executable, depending shared libraries, configuration files, data files, etc. Name it app-name-source (e.g. app-redis-source).
• Download the source code for the application (use apt source or find the source code somwhere else, like GitHub)
• Build the application following the instructions provided.
• Update or create any configuration files, if required.
• Run the executable locally, to test it.
• Run the extract.sh script to pack the application.
• Build a bash script that does all the steps you just did (downloads the sources, builds the application, creates the config files, calls the extract.sh script).
  You can take a peek at the static-pie scripts (app-nginx for example).
• Now profit. Use app-elfloader.

Hackathon points: 40