MacoraOne – A C bytecode VM, language runtimes, and developer tools

Website: https://macoraone.dominextechdocumentary.workers.dev/

Browse the project directory, MacoraOne CLI guide, NativeFlexi, CMLL, and greenServeFE, plus the MVM virtual machine.

Native Android Development Template

NativeFlexi Android is a ready-to-use Android project template for developers who want to build native Android applications using standard Java or Kotlin, Android SDK tools, Gradle, XML resources, and Android Studio.

NativeFlexi does not introduce a custom programming language, custom compiler, custom UI syntax, or generated runtime.

Developers work directly with normal Android project files and can modify the application according to their own requirements.

The repository provides two independent Android templates:

NativeFlexi-android │ ├── NativeFlexi-java/ │ └── Java Android application │ ├── NativeFlexi-kotlin/ │ └── Kotlin Android application │ └── .github/ └── workflows/ ├── android-java.yml └── android-kotlin.yml

MacoraOne

One Technology Ecosystem. Multiple Possibilities.

MacoraOne is a software technology ecosystem focused on programming languages, developer tools, server-side development, command-line utilities, Android development, runtime systems, virtual machines, and resources for modern software engineering.

Our goal is to bring independent developer projects together under one unified technology ecosystem, making software development more accessible, practical, and extensible.

From programming languages and runtime systems to server infrastructure, command-line tools, Android development templates, and AI-oriented datasets, MacoraOne brings together technologies designed to support developers, learners, and technology builders.

NativeFlexi Android is part of the MacoraOne ecosystem.

MacoraOne is the unified technology identity for a collection of software development projects created by Dominex Macedon.

The ecosystem includes programming languages, runtime components, virtual machines, server development utilities, command-line tools, Android development resources, developer tooling, and data resources for AI-related research and development.

Each project serves a different purpose while contributing to a broader vision: building practical software technologies that developers can explore, use, modify, and extend.

For information about the creator and developer behind MacoraOne, see ABOUT_DEVELOPER.md.

Programming language development

Server-side programming

Android development

Native Java and Kotlin development

Developer tools and runtime systems

Virtual-machine and bytecode technologies

Command-line software

AI-oriented programming language datasets

Open-source software experimentation

Accessible developer experiences

NativeFlexi Android

NativeFlexi Android provides a conventional Android project structure that developers can clone, fork, modify, and use as the foundation for their own applications.

There are no special NativeFlexi source files that developers need to learn.

The repository is intended to provide a clean starting point rather than hide Android development behind another abstraction.

The MacoraOne one command provides the standard workflow for creating and building NativeFlexi Android applications.

Download and install the latest one release as /usr/local/bin/one:

set -eu

URL="https://github.com/MacoraOne/MacoraOne/releases/download/one-v1.0.1/macoraone-linux-x86_64.zip" TMP_DIR="$(mktemp -d)" trap 'rm -rf "$TMP_DIR"' EXIT

curl -fL "$URL" -o "$TMP_DIR/macoraone-linux-x86_64.zip" unzip -q "$TMP_DIR/macoraone-linux-x86_64.zip" -d "$TMP_DIR/extracted"

BIN="$(find "$TMP_DIR/extracted" -type f ( -name 'macoraone' -o -name 'macoraone-linux-x86_64' -o -name 'one' ) -print -quit)" if [ -z "$BIN" ]; then echo "Error: MacoraOne executable was not found in the release ZIP." >&2 find "$TMP_DIR/extracted" -maxdepth 3 -type f -print >&2 exit 1 fi

chmod +x "$BIN" sudo install -m 0755 "$BIN" /usr/local/bin/one

one --version one --help

Requirements on Debian/Ubuntu: curl, unzip, and sudo. Install the dependencies with sudo apt-get update && sudo apt-get install -y curl unzip if needed.

Release ZIP: macoraone-linux-x86_64.zip (one-v1.0.1).

one create AppName

Build an application

Build using the default build mode:

one build AppName

Build all available Android artifacts:

one build AppName all

Build the debug APK:

one build AppName debug

Build the release APK and AAB:

one build AppName release

Command information

Show the installed MacoraOne version:

one --help

Choose Java or Kotlin

NativeFlexi Android provides two separate templates.

NativeFlexi-java/

The Java project uses:

build.gradle settings.gradle *.java

The main application source is:

NativeFlexi-java/app/src/main/java/com/nativeflexi/MainActivity.java

Build it with:

cd NativeFlexi-java gradle assembleDebug --no-daemon

Kotlin

Use:

NativeFlexi-kotlin/

The Kotlin project uses:

build.gradle.kts settings.gradle.kts *.kt

The main application source is:

NativeFlexi-kotlin/app/src/main/java/com/nativeflexi/MainActivity.kt

Build it with:

cd NativeFlexi-kotlin gradle assembleDebug --no-daemon

Choose the language you want to use and develop that project independently.

Developers can clone the repository directly:

git clone https://github.com/dominexmacedon-docs/NativeFlexi-android.git

Then enter the repository:

NativeFlexi-kotlin

Open the selected directory in Android Studio.

NativeFlexi Android is designed to be forkable.

A developer can create their own GitHub fork and use the fork as the starting point for a new Android application or development project.

NativeFlexi-android │ └── Fork │ ▼ Developer's GitHub repository │ ├── Modify Java/Kotlin ├── Modify XML resources ├── Modify Manifest ├── Modify Gradle ├── Add dependencies └── Build application

After creating a fork, clone the developer's fork locally:

git clone https://github.com/YOUR-USERNAME/NativeFlexi-android.git

Then:

cd NativeFlexi-android

The developer can make their changes and push them to their own repository.

git add . git commit -m "Customize Android application" git push

This allows developers to maintain their own version without modifying the original MacoraOne NativeFlexi repository.

NativeFlexi is intentionally based on normal Android project files.

Developers can directly edit the following.

NativeFlexi-java/app/src/main/java/

Kotlin:

NativeFlexi-kotlin/app/src/main/java/

Developers can add:

NativeFlexi-java/app/src/main/AndroidManifest.xml

or:

NativeFlexi-kotlin/app/src/main/AndroidManifest.xml

Developers can modify the manifest to add application components and configuration.

For permissions that require user approval at runtime, developers must also implement the appropriate runtime permission handling in Java or Kotlin.

app/src/main/res/

The template includes standard Android resources such as:

res/ ├── layout/ ├── values/ ├── drawable/ ├── mipmap/ ├── menu/ └── xml/

Developers can add or modify resources according to their application.

activity_main.xml

Developers can replace the sample interface with their own Android UI.

app/src/main/res/values/strings.xml

Colors

Colors are stored in:

app/src/main/res/values/colors.xml

Themes

Themes are stored in:

app/src/main/res/values/themes.xml

Developers can modify these files or introduce additional Android resource configurations.

NativeFlexi uses standard Android Gradle configuration.

NativeFlexi-java/build.gradle NativeFlexi-java/settings.gradle NativeFlexi-java/app/build.gradle

Kotlin:

NativeFlexi-kotlin/build.gradle.kts NativeFlexi-kotlin/settings.gradle.kts NativeFlexi-kotlin/app/build.gradle.kts

Developers can modify the Gradle configuration to customize their application.

The application namespace and package configuration can be changed in the module Gradle file.

namespace = "com.nativeflexi"

The application ID is also configurable:

applicationId = "com.nativeflexi"

Developers should change these values when creating a separate application.

com.example.myapplication

The Java or Kotlin package declarations should be updated consistently with the selected namespace and source structure.

The template specifies Android SDK versions in the Gradle configuration.

compileSdk minSdk targetSdk

according to their application's requirements and the Android SDK versions installed in their development environment.

compileSdk = 35 minSdk = 24 targetSdk = 35

These values are examples used by the template and can be changed when necessary.

Application dependencies are declared in:

implementation(...)

Developers can add Android libraries and other compatible dependencies as required.

When adding a dependency, developers should verify:

NativeFlexi includes standard Android build types.

debug release

Developers can customize build types for their application.

Sensitive signing credentials should never be committed to the repository.

The recommended development environment is Android Studio.

Android Studio can synchronize the Gradle project and provide:

Java

cd NativeFlexi-java gradle assembleDebug --no-daemon

The debug APK is generated under:

app/build/outputs/apk/debug/

Kotlin

cd NativeFlexi-kotlin gradle assembleDebug --no-daemon

The debug APK is generated under:

app/build/outputs/apk/debug/

GitHub Actions

NativeFlexi provides separate GitHub Actions workflows for the Java and Kotlin templates.

.github/workflows/ ├── android-java.yml └── android-kotlin.yml

Developers can manually choose the workflow corresponding to the project they are developing.

NativeFlexi-java

Kotlin Workflow

android-kotlin.yml

Builds:

NativeFlexi-kotlin

The workflows install the required Android SDK packages, build the debug APK, and upload the resulting APK as a GitHub Actions artifact.

Developers can modify these workflows when their own project requires additional SDK packages, tests, signing configuration, or deployment steps.

.java .kt .xml .gradle .gradle.kts

files.

This keeps the project compatible with conventional Android development workflows.

1. Choose Java or Kotlin
2. Open the selected project in Android Studio
3. Change the application namespace
4. Change the application ID
5. Update the application name
6. Modify MainActivity
7. Create your application UI
8. Add required resources
9. Configure AndroidManifest.xml
10. Add required dependencies
11. Configure SDK versions
12. Configure build types
13. Test on an emulator or physical device
14. Build the debug APK
15. Configure release signing when ready
16. Commit your application
17. Push your changes

Repository Structure

NativeFlexi-android/ │ ├── NativeFlexi-java/ │ ├── app/ │ │ ├── src/ │ │ │ └── main/ │ │ │ ├── AndroidManifest.xml │ │ │ ├── java/ │ │ │ │ └── com/nativeflexi/ │ │ │ │ └── MainActivity.java │ │ │ └── res/ │ │ │ ├── layout/ │ │ │ └── values/ │ │ ├── build.gradle │ │ └── proguard-rules.pro │ │ │ ├── build.gradle │ ├── gradle.properties │ └── settings.gradle │ ├── NativeFlexi-kotlin/ │ ├── app/ │ │ ├── src/ │ │ │ └── main/ │ │ │ ├── AndroidManifest.xml │ │ │ ├── java/ │ │ │ │ └── com/nativeflexi/ │ │ │ │ └── MainActivity.kt │ │ │ └── res/ │ │ │ ├── layout/ │ │ │ └── values/ │ │ ├── build.gradle.kts │ │ └── proguard-rules.pro │ │ │ ├── build.gradle.kts │ ├── gradle.properties │ └── settings.gradle.kts │ ├── .github/ │ └── workflows/ │ ├── android-java.yml │ └── android-kotlin.yml │ ├── .gitignore ├── LICENSE └── README.md

MacoraOne Ecosystem

MacoraOne │ ├── Programming Languages │ ├── Puma │ │ ├── Puma Language │ │ └── Puma Runtime │ │ │ ├── greenServeFE- │ │ ├── Interpreter │ │ ├── Compiler │ │ ├── Bytecode │ │ ├── Virtual Machine │ │ └── Native Modules │ │ │ └── CMLL │ └── Command-Line Programming │ ├── Android Development │ └── NativeFlexi Android │ ├── Java Template │ ├── Kotlin Template │ ├── Android SDK │ ├── Gradle │ └── GitHub Actions │ ├── AI & Data │ └── Puma Data for AI Models │ └── Developer Ecosystem ├── Language Tooling ├── Runtime System