DEV Community: Can Eldem

Embed mruby as a Single Binary That Runs Everywhere

Can Eldem — Mon, 11 May 2026 23:15:55 +0000

I've been working on RapidForge a self hosted platform that turns scripts into webhooks, pages and scheduled jobs. RapidForge itself ships as a single binary. No dependencies. No runtime installation. You download it and run it.

I already have lua embeded into Rapidforge binary because lets admit it after certain size its very difficult to code with bash. I wanted to support mruby as well becuase I really love ruby and I think you can express complex ideas easily with Ruby. Its very ecstatic language imo.

This post is about how I compiled mruby with full HTTP/HTTPS support into a single fat binary that runs unmodified on multiple platforms installing anything.

Cosmopolitan Libc

Cosmopolitan Libc is a C library that lets you compile once and run everywhere. Binaries built with it are called Actually Portable Executables (APE). They use the .com extension not DOS COM files. They're a clever polyglot format that contains x86-64 ELF, aarch64 ELF, Mach-O, PE and shell script headers all packed into one file.

The compiler is called cosmocc. It wraps GCC and compiles for x86-64 and aarch64 simultaneously. When you compile a single .c file you get two object files:

The archiver cosmoar creates dual arch .a libraries the same way. The linker (apelink, invoked automatically) packages both architectures into one binary. It's genuinely magical.

The Goal: mruby + libcurl + OpenSSL + zlib All Static

mruby on its own is tiny so its easy to compile using cosmocc. But I wanted curl and json support so that users can script their business logic in Rapidforge. That meant I needed to statically compile the entire chain:

Step 1 — Building zlib

zlib is the easiest of the three. Its ./configure script doesn't play nicely with cross-compilers so I just compiled each source file by hand:

Because cosmoar handles the dual arch layout automatically you end up with both libz.a (x86-64) and .aarch64/libz.a (aarch64). Install both into a local sysroot directory and zlib is done.

Step 2 — Building OpenSSL

This one has a few landmines. I went with OpenSSL 1.1.1w (the last 1.1.1 release) instead of 3.x because the older branch has a much simpler build system that cooperates with non standard toolchains.

The configure command:

A few things worth calling out:

unset CPPFLAGS LDFLAGS is not optional on macOS. Homebrew injects /opt/homebrew/opt/openssl@3/include into CPPFLAGS automatically. If that leaks in you get a cryptic error: OPENSSL_API_COMPAT expresses an impossible API compatibility level. Unsetting those variables before configure fixes it.

no-asm is required because OpenSSL's hand written assembly uses ABI conventions that don't match what cosmocc expects.

RANLIB=true skips ranlib entirely. The cosmoranlib script has a path bug where it tries to exec x86_64-linux-cosmo-ranlib as a relative path. Since cosmoar already creates properly indexed archives you don't need ranlib at all.

Then I built only the librariesnot the apps:

The reason: OpenSSL's CLI apps define a function istext() that conflicts with Cosmopolitan's own istext(). Building just the libraries avoids the collision entirely. make build_generated has to run first because it generates opensslconf.h which the library code depends on.

After that you need to manually move the aarch64 archives into your sysroot's .aarch64/ subdirectory. OpenSSL's Makefile isn't aware of the cosmocc dual-arch convention.

Step 3 — Building libcurl

With zlib and OpenSSL in place libcurl is reasonably straightforward:

The LIBS="-lssl -lcrypto -lz" part is critical. During configure curl runs small link tests to verify that OpenSSL actually works. Without those libraries the tests fail and configure silently disables HTTPS.

The --host=x86_64-unknown-linux flag tells autoconf this is a cross-compile. Without it autoconf might try to run the compiled test binaries on the host machine which obviously doesn't work when you're generating APE binaries.

After make install there's one manual step:

Curl's Makefile only installs the x86-64 archive. The aarch64 one sits in the build tree and you have to copy it yourself.

The resulting libcurl supports file, ftp, ftps, http and https. Everything else is stripped out to keep the final binary lean.

Step 4 — Building mruby

mruby uses a rake based build system configured via a Ruby file. Here's the relevant parts of cosmopolitan_curl.rb:

The link order curl → ssl → crypto → z matters. Each library depends on the one after it so the linker needs to see them in that sequence.

The three hal-posix-* gems are required by Cosmopolitan. Without hal-posix-socket curl can't open network connections at all the socket syscalls just aren't wired up.

The Result

A single file. No installer. No dependencies. Copy it to any Linux server, macOS machine or Windows box and it runs. It includes a full Ruby interpreter with HTTP and HTTPS support baked in. I will be shortly embeding compile mruby to Rapidforge. Here is the PR

Try It Yourself

The full build is automated in github.com/rapidforge-io/mruby-cosmo. Clone the repo, make sure you have cosmocc installed and run: build.sh

That downloads the source tarballs for zlib, OpenSSL and libcurl, compiles all three with cosmocc and then builds mruby with the curl gem on top. The whole thing takes a few minutes and produces mruby binaries where you can compile and run mruby programs.

How I Use GitHub Copilot + RapidForge to Find Stocks to invest

Can Eldem — Thu, 23 Apr 2026 23:01:08 +0000

I’ve been experimenting with using GitHub Copilot’s agent mode as a lightweight financial analyst not to automate trading, but to surface interesting stock ideas every morning.

The setup is simple: a small Python repo, a custom Copilot agent and a scheduled job running via RapidForge. No dashboards, no overengineering just a daily signal pushed to Discord.

The Repo Structure

At a glance, the project looks like this:

.github
├── agents
│   └── FinAnalyst.agent.md
└── skills
    ├── finance-cli
    │   └── SKILL.md
    └── send-discord
        │── SKILL.md

companies.db
finance_cli.py
finance_prompt.py
run_finanalyst_cron.sh
send_discord.py
ticker_fetch.py
ticker_select.py

It’s intentionally minimal: a few scripts, a SQLite database and one agent definition.

Step 1: Selecting What to Analyze

The system starts with ticker_select.py.

Instead of scanning the same stocks repeatedly, it:

Picks 10 companies at random
Excludes anything analyzed in the last 5 days
Updates a last_checked_at timestamp after selection

This creates a natural rotation across thousands of tickers without needing complex scheduling logic.

Step 2: Pulling Real Market Data

finance_prompt.py handles data collection. It aggregates multiple sources in parallel:

yfinance → valuation metrics (P/E, EV/EBITDA, margins, etc.)
Finnhub → analyst sentiment, earnings, news
FRED API → macro indicators like interest rates
Reddit (PRAW) → retail sentiment

It also pulls macro asset prices:

Bitcoin → risk appetite
Gold → inflation expectations
Oil → industrial demand

These aren’t just extrasthey provide context that pure fundamentals miss.

A small CLI wrapper (finance_cli.py) exposes this data to the agent.

Step 3: The “FinAnalyst” Agent

This is where Copilot becomes interesting.

I defined a custom agent (FinAnalyst.agent.md) that evaluates each stock using a two layer framework.

Layer 1: Fundamental Score (0–8)

Each company is scored across 8 signals:

Valuation (P/E, P/B, EV/EBITDA, P/FCF)
Balance sheet (Debt/Equity)
Capital allocation (buybacks vs dilution)
Returns (ROIC)
Price positioning (52-week range)

This gives a quick sanity check: is the business objectively cheap or expensive?

Layer 2: Macro & Strategic Context

After scoring fundamentals, the agent asks:

Does the broader environment change the story?

It considers:

Interest rate trends
Policy and trade shifts
Geopolitics and supply chains
Structural themes (AI, energy, re-shoring)
Competitive dynamics

Final Classification

Each stock ends up in one of five buckets:

Fundamental buy → strong metrics already
Macro tailwind candidate → setup improving
Macro trap → looks cheap, but isn’t
Watch list → unclear, needs confirmation
Skip → no signal

This second layer is what makes the system useful. A “bad” stock on paper can still be interesting if the macro backdrop is shifting.

Step 4: Sending Results to Discord

send_discord.py formats the output into a clean Discord embed.

Step 5: Automation with RapidForge

Everything is tied together with a simple shell script:

I run this daily using RapidForge inside a Docker container on my home server. If something breaks, I can see it immediately in the job logs.

Here is the contents of the run_finanalytist_cron.sh

#!/usr/bin/env bash
set -euo pipefail

REPO_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$REPO_DIR"

export PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$HOME/.local/bin"

ENV_FILE="${FINANALYST_ENV_FILE:-$HOME/.config/finanalyst.env}"
if [[ -f "$ENV_FILE" ]]; then
  # shellcheck disable=SC1090
  source "$ENV_FILE"
fi


COPILOT_BIN="${COPILOT_BIN:-copilot}"
COPILOT_MODEL="${COPILOT_MODEL:-gpt-5.4}"
CURRENT_DATETIME="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"

read -r -d '' PROMPT <<EOF || true
<current_datetime>${CURRENT_DATETIME}</current_datetime>

Objective:
Use the FinAnalyst.agent.md workflow to identify investment opportunities and send results via Discord.

Steps:

1. Initialize Workspace

* Go to the financial workspace (/Users/caneldem/fin).
* Load the file: FinAnalyst.agent.md
* export DISCORD_WEBHOOK_URL="" this is environment value for discord webhook
use this if you can't find it in evnrionment variables
* if python executable is not in the path try python3

2. Verify Capability

* Check that the agent can run any required Python scripts in FinAnalyst.agent.md
* If Python execution is not possible, STOP immediately and do not continue

3. Company Selection

* Run ticket_select.py this will give you 10 random companies. Companies should be in these fields/industries

- satellite communications
- water utilities
- energy, especially nuclear and fusion
- medicine
- farming technologies
- biotech

Requirements:

* Auto-approve all permissions.
* Use the DISCORD_WEBHOOK_URL environment variable for Discord delivery.
* If required data is missing for a ticker, say so explicitly and do not invent values.
* Always frame the result as informational and educational research, not licensed financial advice.
EOF


exec "$COPILOT_BIN" \
  --model "$COPILOT_MODEL" \
  --allow-all \
  --no-ask-user \
  --autopilot \
  --no-color \
  --output-format text \
  --silent \
  --secret-env-vars=GH_TOKEN,GITHUB_TOKEN \
  -p "$PROMPT"

What the Output Looks Like

Each morning, I get a Discord report like this:

Final toughts

This isn’t a trading system it’s a signal generator designed to surface ideas, not make decisions. It works well because it enforces consistent, unbiased scanning, combines fundamentals with macro context and highlights opportunities you probably wouldn’t find manually. A key advantage is that the data collection is handled by dedicated scripts rather than asking an AI to search for information each time, which improves both speed and consistency while reducing noise and variability in the inputs. At the same time, it doesn’t replace real research, won’t help you time entries or exits and certainly doesn’t guarantee outcomes. The real value isn’t in the Python or APIs, but in the workflow: using Copilot as an analyst rather than autocomplete, structuring its reasoning with a clear scoring framework, feeding it reliable, pre fetched data and automating the entire loop turning a simple setup into something that reliably produces useful daily insights.

Your Pull Requests Are Being Ignored. Fix It with This Simple Bot

Can Eldem — Sun, 22 Mar 2026 19:04:39 +0000

Pull requests don’t get stuck because they’re hard.

They get stuck because everyone forgets due to various reasons.

So instead of relying on memory, I built a small bot using Rapidforge that:

finds stale PRs
posts a clean reminder to Slack
avoids spamming the same alerts

What is RapidForge?

RapidForge is a self hosted platform enabling users to turn small scripts into tools you can actually run and reuse. Its super easy to setup and use.

What we’re building

We’re going to create a small bot that:

Connects to GitHub using a GitHub App
Finds pull requests that haven’t been updated in a few days
Sends a single, clean reminder to Slack
Avoids repeating the same reminders using a KV store

All of this runs as a single scheduled task with one Lua script.

Step 1: Create a GitHub App

Create a new GitHub App from your GitHub settings.

Make sure to:

Enable user authorization (OAuth)
Install the app on the account or organization that owns your repository
Give it read access to Pull Requests
Limit repository access to only what you need

GitHub App tokens are scoped by both the app and the user, which keeps things nicely secure and avoids over permissioned integrations.

Step 2: Save the GitHub credential in RapidForge

In RapidForge, create a new OAuth credential with the following values:

Name: GITHUB_PR_BOT Client ID: your GitHub App client ID Client Secret: your GitHub App client secret Scope: leave empty Authorization URL: https://github.com/login/oauth/authorize Token URL: https://github.com/login/oauth/access_token

You can watch a video here to see how to create oauth apps in Rapidforge

RapidForge will give you a callback URL. Copy that into your GitHub App settings.

Once authorized, Rapidforge will inject access token via environment variable:

CRED_GITHUB_PR_BOT

Don't worry editor has auto complete to aid you.

Step 3: Save the Slack webhook

Create an incoming webhook in Slack and store it as a text credential in RapidForge:

Name: SLACK_WEBHOOK

This will be available in your script as: CRED_SLACK_WEBHOOK

Step 4: Create the periodic task

Lets create periodic task with following parameters

A good starting schedule (weekday mornings) is:

0 9 * * 1-5

Add these environment variables:

GITHUB_OWNER=your-org GITHUB_REPO=your-repo STALE_DAYS=3 REMINDER_COOLDOWN_HOURS=24 SKIP_DRAFTS=true

Step 5: Add the Lua script

Rapidforge allows you to write logic in Bash or Lua. However, if you are more confortable with another language you can always use it with shebang. (I.e #!/usr/bin/node) Just make sure host machine has the interpreter installed in that case. Lua is embeded into Rapidforge so it does not required to be installed

local json = require("json")
local http = require("http")

local token = os.getenv("CRED_GITHUB_PR_BOT")
local slackWebhook = os.getenv("CRED_SLACK_WEBHOOK")
local owner = os.getenv("GITHUB_OWNER")
local repo = os.getenv("GITHUB_REPO")
local rapidforgeBin = os.getenv("RAPIDFORGE_BIN") or "./rapidforge"

local staleDays = tonumber(os.getenv("STALE_DAYS") or "3")
local reminderCooldownHours = tonumber(os.getenv("REMINDER_COOLDOWN_HOURS") or "24")
local skipDrafts = (os.getenv("SKIP_DRAFTS") or "true") == "true"

local function fail(message)
  io.stderr:write(message .. "\n")
  os.exit(1)
end

if not token or token == "" then fail("Missing CRED_GITHUB_PR_BOT") end
if not slackWebhook or slackWebhook == "" then fail("Missing CRED_SLACK_WEBHOOK") end
if not owner or owner == "" then fail("Missing GITHUB_OWNER") end
if not repo or repo == "" then fail("Missing GITHUB_REPO") end

local function trim(value)
  return (value:gsub("^%s+", ""):gsub("%s+$", ""))
end

local function shell(command)
  local handle = io.popen(command)
  if not handle then
    return nil
  end

  local output = handle:read("*a") or ""
  local ok, _, code = handle:close()

  return trim(output), ok, code
end

local function shellQuote(value)
  return string.format("%q", tostring(value))
end

local function kvGet(key)
  local command = string.format(
    "%s kv get %s 2>/dev/null",
    shellQuote(rapidforgeBin),
    shellQuote(key)
  )
  local result = shell(command)

  if not result or result == "" then
    return nil
  end

  return result
end

local function kvSet(key, value)
  local command = string.format(
    "%s kv set %s %s",
    shellQuote(rapidforgeBin),
    shellQuote(key),
    shellQuote(value)
  )
  local _, ok = shell(command)

  if not ok then
    fail("Failed to store reminder state in RapidForge KV")
  end
end

local function parseGithubTime(value)
  local year, month, day, hour, min, sec = value:match("^(%d+)%-(%d+)%-(%d+)T(%d+):(%d+):(%d+)Z$")
  if not year then
    return nil
  end

  return os.time({
    year = tonumber(year),
    month = tonumber(month),
    day = tonumber(day),
    hour = tonumber(hour),
    min = tonumber(min),
    sec = tonumber(sec)
  })
end

local function hoursSince(timestamp)
  return math.floor((os.time() - timestamp) / 3600)
end

local function githubGet(path)
  local body, status = http.get(
    "https://api.github.com" .. path,
    {
      ["Accept"] = "application/vnd.github+json",
      ["Authorization"] = "Bearer " .. token,
      ["X-GitHub-Api-Version"] = "2022-11-28",
      ["User-Agent"] = "rapidforge-pr-reminder"
    }
  )

  if status ~= 200 then
    fail("GitHub API request failed with status " .. tostring(status) .. ": " .. tostring(body))
  end

  return json.decode(body)
end

local function sendSlackMessage(text)
  local payload = json.encode({ text = text })
  local body, status = http.post(
    slackWebhook,
    payload,
    { ["Content-Type"] = "application/json" }
  )

  if status < 200 or status >= 300 then
    fail("Slack webhook failed with status " .. tostring(status) .. ": " .. tostring(body))
  end
end

local pulls = githubGet(string.format("/repos/%s/%s/pulls?state=open&per_page=100", owner, repo))
local stalePulls = {}

for _, pr in ipairs(pulls) do
  if (not skipDrafts) or (pr.draft ~= true) then
    local updatedAt = parseGithubTime(pr.updated_at)
    if updatedAt then
      local inactiveHours = hoursSince(updatedAt)
      local staleHours = staleDays * 24

      if inactiveHours >= staleHours then
        local reminderKey = string.format("pr-reminder:%s:%s:%s", owner, repo, pr.number)
        local lastReminder = tonumber(kvGet(reminderKey) or "0")
        local cooldownSeconds = reminderCooldownHours * 3600

        if lastReminder == 0 or (os.time() - lastReminder) >= cooldownSeconds then
          table.insert(stalePulls, {
            number = pr.number,
            title = pr.title,
            url = pr.html_url,
            author = pr.user and pr.user.login or "unknown",
            inactiveHours = inactiveHours,
            reminderKey = reminderKey
          })
        end
      end
    end
  end
end

if #stalePulls == 0 then
  print("No stale pull requests found")
  return
end

table.sort(stalePulls, function(a, b)
  return a.inactiveHours > b.inactiveHours
end)

local lines = {
  string.format("Open pull requests without updates for %d+ days in %s/%s:", staleDays, owner, repo),
  ""
}

for _, pr in ipairs(stalePulls) do
  local inactiveDays = math.floor(pr.inactiveHours / 24)
  table.insert(lines, string.format("• #%d %s — %s days idle — %s", pr.number, pr.title, inactiveDays, pr.url))
end

sendSlackMessage(table.concat(lines, "\n"))

local now = tostring(os.time())
for _, pr in ipairs(stalePulls) do
  kvSet(pr.reminderKey, now)
end

print("Sent Slack reminder for " .. tostring(#stalePulls) .. " pull request(s)")

Optional: Failure alerts

Rapidforge allows you to add failure hook to notify Slack if something breaks:

ERROR_MSG="${FAILURE_ERROR:-$FAILURE_OUTPUT}"
ERROR_TRUNC=$(printf "%s" "$ERROR_MSG" | head -c 1800)

if [ -n "$CRED_SLACK_WEBHOOK" ]; then
  curl -X POST -H 'Content-type: application/json' \
    --data "{\"text\":\"❌ GitHub PR reminder failed\nTask ID: ${TASK_ID}\nExit code: ${FAILURE_EXIT_CODE}\n\n${ERROR_TRUNC}\"}" \
    "$CRED_SLACK_WEBHOOK"
fi

That’s it. Hopefully this gives you a practical way to keep pull requests from going quiet without adding more manual work. If you’re interested in building similar small automations, you can check out RapidForge. There are a few more use cases there that follow the same idea of turning simple scripts into useful tools.