Forem: Milton Vafana

Bridging Rust and PHP with whyNot: A Learner’s Journey

Milton Vafana — Sun, 11 Jan 2026 16:30:11 +0000

Bridging Rust and PHP with whyNot: A Learner’s Journey

When you’re learning a new language, the temptation is to start small: toy projects, simple exercises, maybe a “Hello World” or two. But I’ve always believed the best way to learn is to build something real, something that scratches an itch and forces you to wrestle with the language in practice. That’s how whyNot came to life — a Rust ↔ PHP bridge that lets you call PHP functions directly from Rust, capture return values, printed output, and exceptions, with async support via threads or Tokio.

I’m still learning Rust myself, and whyNot is as much a learning experiment as it is a tool. But it’s already proving useful, and I want to share the story, the features, and the lessons I’ve learned along the way.

Why I Built whyNot

PHP has been my bread and butter for years. I love PHP — it’s the language I’m most comfortable with, the one I’ve used to build countless projects, and the one I trust when I need to get things done quickly. It powers much of the web, from WordPress to Laravel to legacy enterprise systems. But PHP has limits, especially when it comes to performance and modern concurrency. Rust, on the other hand, is fast, safe, and designed for systems programming. The idea of combining them fascinated me.

Instead of rewriting PHP applications in Rust (which is unrealistic for most teams), I thought: why not build a bridge? Why not let Rust call into PHP directly, so developers can leverage existing PHP logic while experimenting with Rust’s ecosystem? And for me personally, why not use this as a fun way to learn Rust by building something ambitious?

That’s the spirit behind the name: whyNot. It’s both a challenge and an invitation.

What whyNot Can Do

Here’s what the crate currently supports:

Call any PHP function from Rust
Capture return values and printed output
Structured exception handling with PhpException
Objects returned with class + fields
Persistent runtime (globals/includes survive across calls)
include and eval support
Async via threads (call_async_with_cfg)
Async/await via Tokio (--features async_tokio)

This means you can write PHP functions in a bootstrap.php file, then call them from Rust as if they were native. You can capture not just the return value, but also whatever the PHP function prints, and handle exceptions in a structured way.

🚀 Getting Started

Installation

Add whyNot to your project:

cargo add whynot

Or in your Cargo.toml:

[dependencies]
whynot = "0.1.1"

You’ll also need PHP CLI (php) available in your PATH.

Initialize PHP scaffolding

After installing the crate, install the CLI binary:

cargo install whynot

Then run:

whynot-init

This creates a php/ folder in your project root with:

runner.php — the bridge script used internally by whyNot
bootstrap.php — where you define your own PHP functions/classes

Edit bootstrap.php to add your PHP logic. The Rust side will call into these functions.

Usage Examples

Basic Call

bootstrap.php:

<?php
function add($a, $b) {
    echo "Adding $a + $b\n";
    return $a + $b;
}

Rust:

use whynot::{new_runtime, PhpRuntime, RuntimeConfig, RuntimeKind};

fn main() {
    let cfg = RuntimeConfig::default();
    let mut rt = new_runtime(RuntimeKind::Process(cfg)).unwrap();
    let result = rt.call("add", &[7.into(), 5.into()]).unwrap();
    println!("add.result = {:?}", result.result);
    println!("add.output = {:?}", result.output);
}

Output:

add.result = Some(12)
add.output = "Adding 7 + 5\n"

Exception Handling

bootstrap.php:

<?php
function risky() {
    throw new Exception("Something went wrong!");
}

Rust:

let boom = rt.call("risky", &[]).unwrap();
if let Some(ex) = boom.exception {
    println!("Exception: {} ({})", ex.message, ex.class);
    println!("Trace: {}", ex.trace);
}

Async with Threads

use whynot::process::ProcRuntime;

let h1 = ProcRuntime::call_async_with_cfg(cfg.clone(), "greet".to_string(), vec!["Milton".into()]);
let h2 = ProcRuntime::call_async_with_cfg(cfg.clone(), "add".to_string(), vec![7.into(), 9.into()]);
println!("greet = {:?}", h1.join().unwrap().unwrap().result);
println!("add = {:?}", h2.join().unwrap().unwrap().result);

Async/Await with Tokio

Enable the feature:

cargo run --example tokio_async --features async_tokio

Example:

#[tokio::main]
async fn main() {
    let cfg = RuntimeConfig::default();
    let greet = whynot::async_tokio::call_async(cfg.clone(), "greet".to_string(), vec!["Milton".into()])
        .await.unwrap();
    println!("greet.result = {:?}", greet.result);
}

Project Layout

whynot/
  Cargo.toml
  src/
    lib.rs
    value.rs
    macros.rs
    process.rs
    embedded.rs
    async_tokio.rs
  php/
    runner.php
    bootstrap.php
  examples/
    call_any.rs
    async_calls.rs
    tokio_async.rs

Roadmap

Function calls, output capture, exceptions ✅
Object serialization ✅
Includes, eval ✅
Threaded async ✅
Tokio async/await ✅
Embedded Zend runtime (in‑process) 🚧
Resource/extension support 🚧
Automatic Rust ↔ PHP struct mapping 🚧

The long-term vision is to make Rust ↔ PHP interop seamless, with support for complex data structures and embedded runtimes.

Learning Rust Through Building

I want to emphasize something: I’m still learning Rust. whyNot wasn’t built from a place of mastery, but from curiosity. I struggled with FFI, lifetimes, and async patterns. I broke things constantly. But each challenge taught me something new and i hope i will get good enough to make it better.

Rust’s strictness forced me to think differently about safety and concurrency. PHP reminded me of pragmatism and flexibility. And because I genuinely love PHP and feel comfortable with it, I wanted this bridge to exist. For me, whyNot is about combining the language I know best with the one I’m still learning, and discovering what happens when they meet.

Closing Thoughts

whyNot is still evolving, but it already opens up exciting possibilities: calling PHP functions from Rust, capturing output, handling exceptions, and running async tasks. For PHP developers curious about Rust, it’s a practical gateway. For Rust learners like me, it’s a hands-on way to explore the language while building something useful.

👉 Source code: GitHub (github.com)

👉 Crate: crates.io

👉 Original post: Medium

Rustnite: Turning Rust Learning Into a Battle Royale

Milton Vafana — Sun, 11 Jan 2026 15:31:19 +0000

Rust is well known for it's steep learning curve. Rust is uncompromising about safety and performance, and that makes it one of the most rewarding languages to master.

I built Rustnite: a gamified, competitive platform where learning Rust feels less like homework and more like a battle royale. Instead of grinding through chapters, you drop into an arena, tackle challenges, earn XP, and climb leaderboards — all while writing real Rust code that compiles and runs in the browser.

👉 Try it now: rustnite.wasmer.app

👉 Explore the repo: Rustnite on GitHub

🎮 What Makes Rustnite Different?

Rustnite isn’t just another coding playground. It’s built to combine learning, competition, and creation:

Battle Royale Learning: Compete against other developers worldwide. Every challenge is a chance to prove your skills.
Gamification That Sticks: Earn XP, unlock achievements, and climb leaderboards. Motivation comes naturally when progress feels like winning.
Real Projects, Not Just Snippets: Build CLI tools, web servers, chat apps, and portfolio-worthy projects directly in the browser.
Live Coding Experience: Powered by Monaco editor and Wasmer, Rustnite gives you instant compilation, syntax highlighting, and real-time feedback.
Community & Collaboration: Share your solutions, learn from others, and showcase your Rust journey.
Free Forever: No paywalls, no credit card required. Just open the site and start coding.

🛠️ How to Get Started

Visit rustnite.wasmer.app.
Register and enter the coding arena.
Start tackling challenges — from beginner syntax to advanced concurrency.
Earn XP, unlock achievements, and climb the leaderboard.
Fork the repo on GitHub to contribute or extend the platform.

🚧 Roadmap Ahead

Rustnite is just getting started. Here’s what’s next:

More challenges and project templates.
Multiplayer modes with live coding battles.
Deeper Wasmer integrations for advanced Rust + Wasm workflows.
Community-driven features: shared snippets, collaborative projects, and tournaments.

✨ Closing Thoughts

Rustnite is about making Rust mastery fun, competitive, and rewarding. Whether you’re new to Rust or sharpening your skills, this is your chance to join the battle, learn faster, and build cooler projects. This is something i was building to try sharpen my skills but this will never surpass platforms like #rustfinity which is an amazing platform to learn rust.

👉 Jump into the arena today: rustnite.wasmer.app

How to Add Live Deploy Status Badges to Your Render Projects

Milton Vafana — Sun, 30 Mar 2025 07:28:16 +0000

Let me introduce you to render-status-badge - a lightweight Node.js tool that generates dynamic status badges for Render deployments using Shields.io and Render's API.

Why You Need This

Instant Visibility: Know if your last deploy succeeded or failed at a glance.
Professional Polish: Make your READMEs look pro with Shields.io badges.
Zero Maintenance: Automatically updates using GitHub Actions.
Multi-Project Ready: Use it across all your Render services.

How It Works in 3 Steps

1. Install the Package

npm install render-status-badge

or run it once without installing

npx render-status-badge

Configure Your Render Credentials

2. Create a .env file with your Render API key and service ID:

RENDER_API_KEY="your_api_key_here" 
RENDER_SERVICE_ID="srv-your-service-id"

Never commit `.env` to Git! Use GitHub Secrets for CI/CD._

3. Add the Badge to Your README

Run the tool to get your badge URL:

npx render-status-badge

Output is something like

https://img.shields.io/badge/Render-Live-brightgreen?logo=render&style=for-the-badge

Then paste the URL into your README.md:

![Render Status](https://img.shields.io/badge/Render-Live-brightgreen?logo=render&style=for-the-badge)

Automate It with GitHub Action (Optional)
For **real-time updates, add this workflow to your repo**

.github/workflows/update-badge.yml:

name: Update Render Status Badge 
on: 
 schedule: 
 - cron: '*/5 * * * *' # Update every 5 minutes 
 workflow_dispatch:
jobs: 
 update-badge: 
 runs-on: ubuntu-latest 
 steps: 
 - uses: actions/checkout@v4 
 - name: Generate Badge 
 env: 
 RENDER_API_KEY: ${{ secrets.RENDER_API_KEY }} 
 RENDER_SERVICE_ID: ${{ secrets.RENDER_SERVICE_ID }} 
 run: npx render-status-badge >> badge-url.txt 
 - name: Update README 
 run: | 
 sed -i "s|<! - RENDER_BADGE →.*|![Render Status]($(cat badge-url.txt))|" README.md 
 git commit -am "Update Render status badge" && git push

Customize Your Badge
Use Shields.io's parameters to tweak the style:

Options

style: for-the-badge (default), flat-square, plastic
label: Custom text like "Deploy Status"
color: Override based on your theme

If you like the project please feel free to Contribute or Star the Project, it lives on GitHub: https://github.com/nia-cloud-official/render-status
I'd love your help!

⭐ Star the repo to show support.
🐛 Report bugs via GitHub Issues.
💡 Suggest features and fixes or submit PRs.

Final Thoughts

Render is an amazing platform, and now it's got a little extra polish. Whether you're managing 1 service or 100, these badges will save you time and keep your team informed.
Go ahead - give your README the glow-up it deserves! ✨

Finding the Right Collaborator on GitHub

Milton Vafana — Sun, 30 Mar 2025 06:54:07 +0000

Finding the right contributor on GitHub.In the fast-paced world of software development, collaboration is key to bringing innovative ideas to life. Whether you're an open-source enthusiast or working on a private project, finding the right collaborator can make a significant difference. In this blog post, we'll explore strategies for finding the perfect collaborator on GitHub and introduce you to a handy tool l designed to streamline this process.

Why Collaboration Matters

Collaboration offers numerous benefits:
Diverse Skill Sets: Teaming up with others brings a variety of skills to the table.
Increased Productivity: Sharing the workload helps in achieving milestones faster.
Learning Opportunities: Collaborating with others allows you to learn new techniques and best practices.
Better Problem Solving: Different perspectives can lead to more effective solutions

Strategies for Finding Collaborators

Leverage GitHub's Search Features

GitHub's search functionality is a powerful tool for finding potential collaborators. You can search for users based on their repositories, contributions, and skills.
Search by Repository: Find users who have worked on projects similar to yours.
Search by Language: Look for users proficient in the programming languages your project requires.
Explore Topics: Use topic tags to discover repositories and contributors with specific interests.

Engage with the Community

Be an active member of the GitHub community:
Participate in Discussions: Join conversations in issues and pull requests.
Contribute to Open Source: Contributing to other projects can help you connect with like-minded developers.
Attend Meetups and Events: GitHub hosts various events where you can meet potential collaborators.

Use Social Media and Forums

Platforms like Twitter, Reddit, and specialized forums can be great places to find collaborators. Share your project details and what you're looking for in a collaborator.

Network with Colleagues and Friends

Don't underestimate the power of your existing network. Let your colleagues and friends know you're looking for collaborators. They might know someone who fits the bill.

Introducing the Collaborator Finder Tool

To simplify the process of finding the right collaborator, l am developing a Collaborator Finder Tool. This application leverages the GitHub API to help you find potential collaborators based on specific criteria.
Features

Search by Username: Quickly find users by their GitHub username.
Search by Skill: Discover users based on their repositories, skills, or interests.
Search by Contributions: Identify users who have contributed to specific repositories.
Filter by Location: Narrow down search results based on geographical location.
User Profiles: View detailed profiles including repositories, contributions, and activity.

Check it out on: https://collaborator-finder-tool.onrender.com/
Find Repo here: https://github.com/nia-cloud-official/collaborator-finder-tool/

I am still learning and trying to advance my coding skills, although l would love to hear your thoughts on the whole idea itself and please do share feedback and contributes are greatly appreciated.

Forem: Milton Vafana

Bridging Rust and PHP with whyNot: A Learner’s Journey

Bridging Rust and PHP with whyNot: A Learner’s Journey

Why I Built whyNot

What whyNot Can Do

🚀 Getting Started

Installation

Initialize PHP scaffolding

Usage Examples

Basic Call

Exception Handling

Async with Threads

Async/Await with Tokio

Project Layout

Roadmap

Learning Rust Through Building

Closing Thoughts

Rustnite: Turning Rust Learning Into a Battle Royale

🎮 What Makes Rustnite Different?

🛠️ How to Get Started

🚧 Roadmap Ahead

✨ Closing Thoughts

How to Add Live Deploy Status Badges to Your Render Projects

Why You Need This

How It Works in 3 Steps

Configure Your Render Credentials

Never commit .env to Git! Use GitHub Secrets for CI/CD._

Finding the Right Collaborator on GitHub

Leverage GitHub's Search Features

Engage with the Community

Use Social Media and Forums

Network with Colleagues and Friends

Introducing the Collaborator Finder Tool

Never commit `.env` to Git! Use GitHub Secrets for CI/CD._