C++ Projects on Upwork: Find Your Next Job

I need production-ready firmware for a Renesas MCU that will exchange data through a Quectel EC200 cellular module using both IEC 60870-5-104 and plain TCP/IP protocols. The code must handle complete data transmission, reception, and on-board processing so the MCU can act as an intelligent field unit that talks reliably to a SCADA master as well as to standard IP services.

Scope
• Build or integrate a lightweight IEC104 stack alongside a TCP socket layer that can coexist without blocking.
• Manage all EC200 interactions (AT commands, connection setup, keep-alive, error recovery) over UART/SPI as appropriate.
• Implement configurable buffers, parsing, and frame validation so that raw sensor payloads can be wrapped/unwrapped for each protocol.
• Provide hooks where my application code can push outgoing payloads and consume validated incoming data.
• Deliver clean, well-commented Embedded-C (or C++) project targeted to Renesas e² studio or similar, plus a brief user guide and test scripts.

Acceptance criteria
1. Demo build loads on the target Renesas board and opens both protocol sessions concurrently.
2. Test bench proves 100 % successful transmit/receive cycles for at least 24 h with no memory leaks.
3. Code passes MISRA-C basic checks and compiles with zero warnings at high warning level.
4. Handoff includes full source, linker files, and step-by-step build instructions.

Please attach a detailed project proposal outlining architecture choices, libraries you plan to use (commercial or open-source), estimated timeline, and your test plan.

Skills: C Programming, Electronics, Microcontroller, Software Testing, Test Automation, C++ Programming, Arduino, Documentation, Embedded Systems, Firmware Development

We're building a system that works similarly to sports auto-tracking cameras (e.g. Veo), but with a simpler, classical computer-vision approach — no deep learning or trained models needed.

What we need:

Camera stitching: Combine footage from two fixed cameras (mounted on one rig, overlapping field of view) into a single panoramic image (~180°), using calibration/homography. The cameras don't move relative to each other, so this should be a one-time calibration applied per frame.
Motion-density tracking: From the panoramic feed, detect where players are concentrated (background subtraction / foreground blob density, not per-object classification) and use that to drive an automatic pan/crop — i.e. a virtual camera that follows the action without a human operator.
Output: a single, smooth, watchable video stream (no visible seam/ghosting at the stitch line, no jittery panning).

What this is NOT: we are not looking for a deep-learning/ball-detection/player-identification system. Classical CV techniques (homography, background subtraction, centroid tracking, Kalman/low-pass smoothing) are the right toolset here — please don't propose a large AI/ML infrastructure buildout.

Ideal candidate:

Strong hands-on experience with OpenCV (stitching, homography, background subtraction)
Has shipped at least one real-time video processing project (not just offline/batch)
Comfortable working with two-camera / multi-camera rigs and frame synchronization
Bonus: experience with sports or surveillance camera systems

Skills: After Effects, C++ Programming, 3D Modelling, 3D Animation, OpenCV, Video Processing, Computer Vision, Video Streaming

We're building a system that works similarly to sports auto-tracking cameras (e.g. Veo), but with a simpler, classical computer-vision approach — no deep learning or trained models needed.

What we need:

Camera stitching: Combine footage from two fixed cameras (mounted on one rig, overlapping field of view) into a single panoramic image (~180°), using calibration/homography. The cameras don't move relative to each other, so this should be a one-time calibration applied per frame.
Motion-density tracking: From the panoramic feed, detect where players are concentrated (background subtraction / foreground blob density, not per-object classification) and use that to drive an automatic pan/crop — i.e. a virtual camera that follows the action without a human operator.
Output: a single, smooth, watchable video stream (no visible seam/ghosting at the stitch line, no jittery panning).

What this is NOT: we are not looking for a deep-learning/ball-detection/player-identification system. Classical CV techniques (homography, background subtraction, centroid tracking, Kalman/low-pass smoothing) are the right toolset here — please don't propose a large AI/ML infrastructure buildout.

Ideal candidate:

Strong hands-on experience with OpenCV (stitching, homography, background subtraction)
Has shipped at least one real-time video processing project (not just offline/batch)
Comfortable working with two-camera / multi-camera rigs and frame synchronization
Bonus: experience with sports or surveillance camera systems

Skills: After Effects, C++ Programming, 3D Modelling, 3D Animation, OpenCV, Video Processing, Computer Vision, Video Streaming

We're building a system that works similarly to sports auto-tracking cameras (e.g. Veo), but with a simpler, classical computer-vision approach — no deep learning or trained models needed.

What we need:

Camera stitching: Combine footage from two fixed cameras (mounted on one rig, overlapping field of view) into a single panoramic image (~180°), using calibration/homography. The cameras don't move relative to each other, so this should be a one-time calibration applied per frame.
Motion-density tracking: From the panoramic feed, detect where players are concentrated (background subtraction / foreground blob density, not per-object classification) and use that to drive an automatic pan/crop — i.e. a virtual camera that follows the action without a human operator.
Output: a single, smooth, watchable video stream (no visible seam/ghosting at the stitch line, no jittery panning).

What this is NOT: we are not looking for a deep-learning/ball-detection/player-identification system. Classical CV techniques (homography, background subtraction, centroid tracking, Kalman/low-pass smoothing) are the right toolset here — please don't propose a large AI/ML infrastructure buildout.

Ideal candidate:

Strong hands-on experience with OpenCV (stitching, homography, background subtraction)
Has shipped at least one real-time video processing project (not just offline/batch)
Comfortable working with two-camera / multi-camera rigs and frame synchronization
Bonus: experience with sports or surveillance camera systems

Skills: After Effects, C++ Programming, 3D Modelling, 3D Animation, OpenCV, Video Processing, Computer Vision, Video Streaming

We're building a system that works similarly to sports auto-tracking cameras (e.g. Veo), but with a simpler, classical computer-vision approach — no deep learning or trained models needed.

What we need:

Camera stitching: Combine footage from two fixed cameras (mounted on one rig, overlapping field of view) into a single panoramic image (~180°), using calibration/homography. The cameras don't move relative to each other, so this should be a one-time calibration applied per frame.
Motion-density tracking: From the panoramic feed, detect where players are concentrated (background subtraction / foreground blob density, not per-object classification) and use that to drive an automatic pan/crop — i.e. a virtual camera that follows the action without a human operator.
Output: a single, smooth, watchable video stream (no visible seam/ghosting at the stitch line, no jittery panning).

What this is NOT: we are not looking for a deep-learning/ball-detection/player-identification system. Classical CV techniques (homography, background subtraction, centroid tracking, Kalman/low-pass smoothing) are the right toolset here — please don't propose a large AI/ML infrastructure buildout.

Ideal candidate:

Strong hands-on experience with OpenCV (stitching, homography, background subtraction)
Has shipped at least one real-time video processing project (not just offline/batch)
Comfortable working with two-camera / multi-camera rigs and frame synchronization
Bonus: experience with sports or surveillance camera systems

Skills: After Effects, C++ Programming, 3D Modelling, 3D Animation, OpenCV, Video Processing, Computer Vision, Video Streaming

We’re looking for an experienced Unreal Engine 5 developer to help with a 3D game project.

The main work will involve C++ development, gameplay systems, and Unreal Engine’s Gameplay Ability System (GAS). We already have the project in development and need someone who can jump in, understand the existing setup, and help build and improve core gameplay features.

You should be comfortable working with both C++ and Blueprints, debugging existing systems, and writing clean, organized code that can be maintained as the project grows.

Main tasks may include:

Building and improving gameplay mechanics
Working with Gameplay Ability System (GAS)
Creating abilities, attributes, effects, cooldowns, and related systems
C++ and Blueprint integration
Character and combat systems
Debugging and fixing gameplay issues
Improving existing code and systems
Helping with performance and optimization where needed

We’re looking for someone who has real experience working on Unreal Engine 5 game projects, especially with C++ and GAS.

When applying, please send examples of Unreal Engine projects you’ve worked on and briefly explain your experience with Gameplay Ability System.

We’re looking for someone reliable who communicates well and can work with us long-term if the first tasks go well.

I need a lightweight key-logging application that runs silently on Windows and continuously captures every keystroke. The program must bundle those logs and forward them automatically to both an email address and a Telegram chat that I will specify during setup.

Stability and stealth are important: the executable should start with Windows, avoid triggering Defender, and write minimal footprints to disk. Logs have to arrive in near-real time or on a schedule I can change in a simple config file.

Deliverables:
• A compiled Windows installer or standalone executable
• A brief setup guide showing how to enter my SMTP credentials and Telegram bot token / chat ID
• Source code so I can review and recompile if needed

Please keep external dependencies to a minimum and choose a well-maintained language or framework so future updates remain straightforward.

Skills: Java, Python, Windows Desktop, C# Programming, Software Architecture, C++ Programming, x86/x64 Assembler, Software Development

We are looking for a talented C++ developer to contribute to our cutting-edge privacy-focused cryptocurrency project. You will play a key role in developing and enhancing the core blockchain infrastructure, implementing advanced cryptographic privacy features, and ensuring the robustness and security of our platform.
Your responsibilities will include coding new features, optimizing existing systems for performance, and working on privacy-preserving technologies such as confidential transactions and anonymous authentication methods. You will collaborate closely with cryptographers, security experts, and product teams to deliver a secure and scalable privacy solution.
You should have a deep understanding of C++, blockchain architecture, and cryptographic protocols. Experience with decentralized systems, consensus algorithms, and privacy technologies will be highly valued. Join us in creating a secure, private, and user-centric digital currency that redefines financial privacy for the future.

We are building a high-fidelity VR simulator for professional welder training. The platform already has realistic visuals, motion tracking, and interactive scenarios. Now we need to add a powerful physics engine that simulates heat transfer, melting, weld pool dynamics, bead formation, and defect detection – all in real time (at 60+ FPS).

We are NOT looking for a theorist. We need a hands-on practitioner who has already implemented similar mathematical models (thermal, fluid, phase-change) in a game engine or interactive simulator, and can deliver a proven, working solution under strict performance constraints.

What you'll do
- Develop and implement a mathematical model of the welding process (heat propagation, melting, flow, solidification) driven by a moving heat source.
- Ensure the model outputs: temperature maps (3D or surface), weld bead geometry evolution, and real-time alerts for local defects (lack of fusion, overheating, porosity, etc.).
- Integrate the model with Unity – propose the architecture, data exchange protocol, and handle latency/performance trade-offs.
- Validate the model against reference data and tune it for a realistic feel.
- Be prepared to challenge our current assumptions and suggest a better approach if needed. We are flexible and value your expertise.

Required skills
- Proven experience in mathematical modeling of physical processes (heat transfer, fluid dynamics, phase transitions) for real-time applications.
- Strong coding skills in C++, C#, Python, or MATLAB – with a focus on performance (multithreading, GPU compute).
- Experience integrating such models with a game engine (Unity preferred; Unreal also considered).
- Deep understanding of numerical methods (FDM, FEM, particle methods) and how to balance accuracy with speed.
- Ability to clearly document your work and communicate complex ideas to a non-specialist team.

How we work
- We are a small, agile team of developers, designers, and engineers.
- We value proactive communication – regular updates, early feedback, and collaborative problem-solving.
- We are open to your ideas: if you think a different modeling approach would work better, we're ready to discuss and pivot.

What we offer
- An engaging, challenging project (minimum 3+ months, likely longer).
- Fully remote collaboration.
- Competitive pay – $20–40/hour, depending on experience and fit.
- A chance to work on a cutting-edge product used by professional welders worldwide.
- Flexible schedule – we focus on results, not hours.

To apply, please include:
1. A brief summary of your relevant experience (especially projects where you integrated physics models into game engines).
2. Your preferred hourly rate and availability.
3. Any questions about the project – we'll be happy to answer.

We look forward to hearing from you!

I’m creating a complete historical total-conversion mod for Mount & Blade: Warband and need an experienced modder who can take the concept from rough notes to a fully playable release. The goal is to replace every native asset that matters—world map, factions, troops, dialogs, equipment, music and UI—so the game feels as though it was originally set in the chosen historical period.

You should already be comfortable with the Warband Module System (Python), OpenBRF for mesh and texture work, and the typical companion tools such as Morgh’s Editor or Blender when custom models are required. If you have experience scripting advanced features like diplomacy, formation AI or custom settlement mechanics, that will help the mod stand out.

Deliverables
• A compiled, ready-to-drop “Modules\MyHistoricalMod” folder that runs on the latest Warband build without manual tweaks.
• All editable source files: module system scripts, PSD/Blend files, BRF packs, and any third-party assets with proof of permission or appropriate licensing.
• A concise read-me covering installation, key features, and instructions for future updates.

For acceptance I’ll test the build on a clean Warband install; any CTDs or obvious historical inconsistencies will need to be resolved before final sign-off. Let me know your experience with previous total conversions and roughly how you’d phase the work so we can lock in milestones and timelines.

Skills: C Programming, Python, Game Design, Software Architecture, C++ Programming, Game Development, Blender, Modding

Project Title: PS1 MIPS Assembly / Ghidra Patch for Twisted Metal 2 Mod

Description:
I am looking for an experienced PS1 reverse engineer and MIPS assembly programmer to fully implement the final boss "Dark Tooth" as two separate, playable characters on the vehicle selection screen in Twisted Metal 2 (US NTSC version, SCUS_943.06).

The project builds on "edgbla's" core mod and "TechieSaru's" models. I will provide the modified SCUS_943.06 executable file to the chosen freelancer.

Requirements (Strictly MIPS assembly patching, no custom external graphics needed):
1. Two Standalone Menu Slots: Expand the character select screen to create two separate slots using the game's existing portraits:
- Slot 1: Dark Tooth Ice Cream Truck (Phase 1)
- Slot 2: Dark Tooth Standalone Flying Head (Phase 2)
2. Boss Special Attack for the Truck: Patch the input handler so that triggering the special weapon fires BOTH the standard ice cream cones and launches the giant flaming clown head projectile, exactly like the original Phase 1 boss fight.
3. Boss Special Attack for the Flying Head: When playing as the standalone flying head, its special weapon must fire its authentic boss weapon (the massive homing pink plasma ball / projectile ID 0x15) along with the ice cream cones.
4. End-Level Cleanup Fix: Ensure that when a match ends, the game's memory cleanup does not despawn the head model or break the vehicle state during the victory screen.

Budget: My absolute maximum budget for this task is 40 USD. It's a quick MIPS patch job since all 3D assets are already integrated. Please only bid if you have proven experience with the PS1 (R3000A) architecture.

Skills: C Programming, Game Design, C++ Programming, Assembly, Game Development, Reverse Engineering, Game Programming

I need help with customization replication in unreal engine that can help me fix the fact that SERVER can see client customization but client cant see server and himself.

this is an mobile game and i work with Epic Online Services (EOS)

I do work with AnyDesk since the game project is very very heavy.

I need a lightweight key-logging application that runs silently on Windows and continuously captures every keystroke. The program must bundle those logs and forward them automatically to both an email address and a Telegram chat that I will specify during setup.

Stability and stealth are important: the executable should start with Windows, avoid triggering Defender, and write minimal footprints to disk. Logs have to arrive in near-real time or on a schedule I can change in a simple config file.

Deliverables:
• A compiled Windows installer or standalone executable
• A brief setup guide showing how to enter my SMTP credentials and Telegram bot token / chat ID
• Source code so I can review and recompile if needed

Please keep external dependencies to a minimum and choose a well-maintained language or framework so future updates remain straightforward.

Skills: Java, Python, Windows Desktop, C# Programming, Software Architecture, C++ Programming, x86/x64 Assembler, Software Development

I need someone with unreal engine multiplayer (ANDROID) expertise to fix my unreal engine character customization replication which is A MESS.

And somehow on mobile is showing differently, (I'm using EOS (Epic Online Services).

I do only work with AnyDesk, the mobile game project is very heavy and for personal reason i do not really want to share it.

Please, im so struggling on this! :/

I have several ongoing initiatives that each require their own AI agent—some conversational, others focused on data extraction or decision support. I need someone who can take an idea, choose an appropriate framework (for example, Python with LangChain or Rasa for chat, TensorFlow or PyTorch for analysis-heavy tasks), and turn that into a production-ready microservice or packaged module.

Typical flow
• Review the project brief with me and translate objectives into agent capabilities
• Propose the tech stack and model choice, clearly explaining trade-offs
• Build, test, and fine-tune the agent, then expose it through a clean API or SDK
• Hand over clear documentation and lightweight maintenance scripts (Docker or similar)

Because each project differs, modular architecture and well-commented code are essential so I can extend or swap components later. Quality is measured by unit tests that hit at least 85 % coverage, latency below 500 ms for inference on standard cloud hardware, and reproducible results via a provided requirements.txt or environment.yaml file.

If this sounds like your wheelhouse, let’s discuss the first agent and establish a repeatable pattern for the rest.

Skills: C Programming, Java, Python, C++ Programming, LangChain, AI Chatbot Development, AI Model Development, AI Agent Swarms

Necesito desarrollar una aplicación para Linux que automatice el procesamiento de imágenes. El objetivo principal es la automatización de tareas, por lo que no requiero una interfaz gráfica compleja; basta con un flujo por línea de comandos o una API sencilla.

Alcance funcional:
• La app debe tomar imágenes de una carpeta (o ruta indicada) y aplicar una serie de operaciones configurables: redimensionar, convertir formato y ejecutar filtros básicos.
• El núcleo de las rutinas de alto rendimiento podrá escribirse en C++ (por ejemplo, usando OpenCV), mientras que la orquestación, configuración y llamadas al sistema estarán en Python.
• Quiero un sistema modular para poder añadir nuevas transformaciones después.

Entregables esperados:
1. Código fuente bien documentado en Python y C++.
2. Script de compilación/instalación y archivo README con dependencias.
3. Pequeño conjunto de pruebas que demuestre el flujo completo (entrada de imágenes → salida procesada).
4. Instrucciones para ejecutar en distribuciones Debian/Ubuntu.

Acepto propuestas sobre bibliotecas adicionales siempre que se mantenga la compatibilidad con Linux. Busco una solución limpia, reproducible y fácil de mantener.

Skills: Python, Linux, Software Architecture, C++ Programming, Ubuntu, Image Processing, OpenCV, Automation

I currently run all of my campaigns from Outlook and I’m ready to let an AI agent take over the repetitive work. Your task is to connect my Outlook account to either Claude or ChatGPT—whichever you feel is best—and build a workflow that can:

• Draft emails directly from the AI based on prompts or pre-set templates
• Queue and schedule those emails to go out at the ideal time without me touching the Outlook interface
• Send the messages through my existing Outlook account and log basic delivery details for later review

I need clean, well-commented code (Python, Node.js, or a language you recommend that works smoothly with Microsoft Graph) plus a short setup guide so I can reinstall the solution on another machine if needed. We’ll run a quick live test: I’ll supply a sample prompt, the agent should generate the email, schedule it for a specified time, and confirm the action back to me.

If you’ve linked Outlook to OpenAI or Anthropic APIs before, or if you’ve already handled Microsoft Graph authentication flows, you’ll be able to move fast on this. Let me know the stack you propose and how long you’ll need to deliver a fully working prototype.

Skills: PHP, Python, Software Architecture, C++ Programming, Node.js, Microsoft Graph, AI Chatbot Development, AI Automation

I need a freelancer to create a clear, engaging 2-minute video that explains a mathematics concept in an easy-to-understand way. The video should be concise, visually simple, and suitable for learners who want a quick explanation. Please share examples of similar educational videos and your approach to making complex ideas easy to follow. This is a small project for someone who can deliver a polished final video quickly.

Je souhaite disposer d’un petit add-on sur mesure pour Archicad 29 qui, une fois installé, insère automatiquement les cotations intérieures de mes plans avec une précision moyenne. L’objectif est de gagner du temps sur cette tâche répétitive et d’éviter les oublis manuels.

Détails techniques
• Langage C++ avec le SDK Archicad 29.
• Compilation au format .apx prêt à être chargé dans Archicad.
• Le code peut avoir été généré par IA ou rédigé à la main : seul le bon fonctionnement m’importe.

Fonctionnement attendu
1. Je lance la commande dans Archicad.
2. L’add-on analyse le plan courant.
3. Il pose automatiquement les cotations intérieures selon les règles par défaut d’Archicad, ajustées pour une précision moyenne (ni trop détaillée, ni trop approximative).
4. Les cotes se placent proprement sans chevauchement.

Livrables
• Fichier .apx compilé et signé si nécessaire.
• Code source complet C++ bien commenté.
• Brève notice d’installation et d’utilisation.
• Petite vidéo ou fichier démo montrant l’add-on en action serait un plus.

Je reste disponible pour fournir un fichier exemple et répondre à vos questions sur les règles de cotation spécifiques à mon flux de travail.

Skills: Building Architecture, 3D Rendering, Home Design, C++ Programming, 3D Modelling, Software Development, Automation, API Development

Project Overview
We’re looking for an experienced embedded hardware/firmware engineer to design a compact, battery‑powered vibration monitoring device that can reliably transmit data over ~3 km using Sub‑GHz wireless. The system must be robust, energy‑efficient, and suitable for outdoor industrial or infrastructure use (e.g., pumps, motors, towers, pipelines).
The end goal is a durable, field‑ready prototype (and ideally a path to production) that combines:
A reliable vibration sensor (MEMS accelerometer or similar)
Efficient power management for multi‑month or multi‑year battery life
Stable long‑range Sub‑GHz communication (e.g., LoRa/LoRaWAN or proprietary Sub‑1 GHz)

Scope of Work
1. Hardware Design
Select and integrate a suitable vibration sensor (e.g., low‑power MEMS accelerometer with appropriate g‑range and bandwidth for machinery/structural monitoring).

Design a compact PCB including:
Microcontroller (low‑power ARM Cortex‑M or equivalent)
Sub‑GHz transceiver or module (e.g., SX126x/SX127x, TI CC13x, STM32WL, etc.)
Power management (LDO/DC‑DC, battery charging if rechargeable, sleep/current optimization)
Memory (if local logging/buffering is needed)
Antenna interface (PCB trace or external connector) and RF matching
Ensure design is optimized for:
Low average current (deep sleep, duty cycling, interrupt‑driven sensing)
Outdoor durability (conformal coating considerations, environmental protection)
Manufacturability (DFM, test points, programming/debug headers)

2. Firmware Development
Develop firmware in C/C++ (preferably on STM32, ESP32‑S3 with Sub‑GHz module, or similar):
Sensor driver and data acquisition (configurable sampling rate, resolution)
On‑device processing (e.g., RMS, peak, FFT features if required)
Power management (sleep modes, wake‑on‑event, duty cycling)
Sub‑GHz stack integration (LoRa/LoRaWAN or custom protocol)
Robust communication:

Configurable transmit interval / event‑triggered reporting
Retries, ACKs, and basic link‑quality monitoring
Secure communication (encryption/authentication if needed)

Provide:

Clean, modular, documented code
Build system (Makefile/CMake/IDE project)
Basic configuration mechanism (e.g., via UART, BLE, or over‑the‑air if applicable)

3. System Integration & Field Testing
Integrate hardware and firmware into a working prototype.

Validate:

Vibration measurement accuracy and noise performance
Power consumption in all modes (active, idle, sleep) and estimated battery life
RF performance at target distances (up to 3 km line‑of‑sight or near‑LOS)
Reliability under realistic outdoor conditions (temperature, humidity, interference)
Provide test reports summarizing:
Current profiles and battery‑life estimates
Link budget calculations and measured range
Any limitations and recommended improvements

4. Documentation & Deliverables
Deliverables include:
Schematics and PCB layout files (Altium, KiCad, or similar)
BOM with supplier links and footprint references
Firmware source code with build instructions
Test procedures and results (power, RF, sensor performance)
Brief design notes explaining key decisions (sensor choice, RF settings, power strategy)

Optional (nice to have):

Enclosure concept or mechanical recommendations for outdoor mounting
Gateway/receiver side example (if custom protocol is used)
Support for integration with cloud or SCADA systems (e.g., MQTT, Modbus)
Required Skills & Experience
Please share specific examples of similar projects you’ve completed. In your proposal, include:

Hardware:

Experience with low‑power embedded PCB design (Sub‑GHz/LoRa, BLE, or similar)
Sensor integration (accelerometers, IMUs, condition‑monitoring sensors)
Power‑optimized designs (battery‑powered, multi‑year life targets)

Firmware:

C/C++ on Cortex‑M or similar MCUs
Wireless stacks (LoRa/LoRaWAN, Sub‑1 GHz, or proprietary RF)
Low‑power techniques (interrupts, DMA, sleep modes)

Field Testing:

Real‑world deployments of wireless sensors (outdoor/industrial)
RF range testing, link‑budget analysis, and troubleshooting

Vibration/condition monitoring applications (motors, pumps, structures, etc.)

Mention:

Key components/modules you’ve used (e.g., SX1262, CC1310, STM32WL, LIS3DH, IIS3DWB, etc.)
Typical battery life achieved in past projects

Maximum reliable range you’ve achieved with Sub‑GHz/LoRa in similar environments

Nice‑to‑Have
Experience with LoRaWAN network servers (ChirpStack, TTN, etc.)
Familiarity with predictive maintenance / industrial IoT platforms
Knowledge of relevant standards (ATEX/IECEx is a plus for hazardous areas, though not required initially)
Ability to support small‑batch production or design handoff to a manufacturer

How to Apply
In your proposal, please include:
A short summary of 2–3 most relevant projects (hardware + firmware + testing).
Your typical approach to achieving long range and low power in Sub‑GHz devices.
Any initial thoughts on architecture for this 3 km vibration monitor (sensor + MCU + RF + power).
Estimated timeline and milestones for a first working prototype.

Your rate and availability.

We’re looking for a long‑term collaborator who can take this from concept to a robust, field‑tested prototype and potentially into production.

micro1 is hiring Senior Software Engineers to help build Reinforcement Learning environments that test AI models' ability to solve real software engineering problems, including bug fixes, feature builds, refactoring, and performance optimization. You will design and implement test environments, validate model behavior, and help improve the reliability and effectiveness of AI-driven software development workflows. This role is ideal for engineers with strong experience in software development and a passion for building systems that push the boundaries of AI in practical engineering contexts.

I already have a full written script and I now need it translated into a short, visually playable demo as quickly as possible. The experience must feel virtually realistic, with high-fidelity graphics, believable interactions, and smooth user flow that matches every beat of the script.

I want the build done in Unreal Engine; please take advantage of its real-time lighting, Nanite/Lumen (if you feel it helps performance), and blueprint or C++—whichever gets us to a stable prototype fastest. The final demo has to run online through a digital download or Web build so I can share a link with stakeholders without extra hardware requirements.

Scope of work
• Block-out → polished scene that reflects the script’s environments, characters, and key interactions
• Core gameplay loop fully functional (player movement, interactive objects, basic UI prompts)
• One complete “vertical slice” that demonstrates visuals, audio, and mechanics together
• Simple start menu plus an exit/credits screen

Acceptance criteria
• Script beats mirrored 1-to-1 in the demo
• No critical bugs or crashes during a 10-minute play-through on a standard PC browser/download build
• File size small enough for easy online sharing (target < 2 GB)

If you’ve shipped or prototyped realistic VR/3D experiences in Unreal before and can hit tight timelines, let’s move fast—I’m ready to provide the script, reference art, and daily feedback the moment we agree to start.

Skills: C# Programming, C++ Programming, 3D Modelling, Unity 3D, Game Development, Unreal Engine, Virtual Reality, 3D Game Art

I receive a fresh Excel workbook every week containing the latest investment-returns figures for multiple portfolios, and I need those numbers keyed into our master tracking file with absolute accuracy.

Here’s what the job involves:
• Open the weekly Excel sheets I supply and enter each data point into the corresponding tabs of my master spreadsheet.
• Double-check totals, percentages and date alignment so the values match the source file exactly—no rounding errors or skipped rows.
• Save and return the updated master file to me by the agreed weekly cutoff, ready for further analysis.

You may use any Excel-friendly workflow that keeps the file structure intact—macros, Power Query, or plain data entry are all fine as long as the final sheet mirrors the source figures 100 %.

Deliverable each week:
1. Updated master Excel workbook with all new return figures populated.
2. A brief note flagging any anomalies you spotted while entering the data.

If you’re comfortable handling repetitive numerical entry with a keen eye for detail, I’d love to work together on this ongoing task.

Skills: C# Programming, Electrical Engineering, C++ Programming, Excel VBA, Excel Macros, Data Analysis, Data Management, MATLAB/Simulink

We’re looking for an experienced Unity C# multiplayer developer for a small paid technical trial before larger development work.

The task is to review one multiplayer gameplay scenario where a client initiates an interaction, the server validates it, updates authoritative state, and synchronizes the result to other players.

Please provide a concise technical review covering:

* Client/server responsibilities
* Server-authoritative validation
* RPC/message flow
* Network ownership
* State synchronization
* Basic performance considerations
* Small C# example or pseudocode

You may use Unity Netcode, Mirror, FishNet, Photon Fusion, or another suitable networking solution.

We’re mainly evaluating your multiplayer architecture decisions, not the amount of code.

Strong experience with Unity, C#, multiplayer systems, networking, synchronization, and optimization is required.

This $5 milestone is only a paid technical evaluation. Successful completion may lead to larger work involving multiplayer gameplay, combat systems, dedicated servers, and optimization.

I want to develop an AI-driven application that takes raw footage and turns it into polished video with minimal manual input. The core idea is to streamline everyday editing tasks—cutting, trimming, colour matching, basic motion graphics—through machine-learning models so I can focus on creative direction instead of button-pushing.

Because the exact feature mix is still open, I’m especially interested in solutions that can easily expand to cover automatic scene detection, audio clean-up and smart title/text overlays as the project grows. Feel free to propose a framework you know well—whether that’s Python with OpenCV, a TensorFlow or PyTorch model, or an integration on top of Adobe’s SDK—so long as the final result runs on Windows and outputs standard formats (MP4, MOV).

Deliverables I expect at this stage:
• A working prototype capable of ingesting at least one sample video, applying AI-powered edits, and exporting a finished file
• Source code with clear comments and setup instructions
• A brief walk-through (video or live demo) that shows how the AI logic is triggered and how to tweak parameters

I’ll test by dropping in a new clip and checking that the tool finishes without errors and delivers a coherent, correctly encoded output. If that pilot goes smoothly, we’ll expand the scope together.

Skills: Python, C++ Programming, ActionScript, Video Editing, OpenCV, Video Processing, AI Development, AI Video Editing

I have a finalist for a low-latency software-developer role and want an experienced engineer to run a focused technical assessment. The candidate works daily with C++ and Python and claims deep exposure to network optimization, real-time data processing and high-frequency trading systems, so the interview needs to probe exactly those areas.

You would design and host a live, screen-sharing session that dives into lock-free C++ patterns, kernel-bypass networking, profiling tools, latency budgeting, and Python-based data pipelines. I will forward the résumé and any code samples in advance; you prepare the questions, run the interview (Zoom, Meet or similar) and challenge the candidate with practical problem-solving rather than trivia.

Deliverables:
• 45-60 min technical assessment, recorded if possible
• Written report summarising strengths, weaknesses, and a clear hire/no-hire recommendation, delivered within 24 h

If you have previously built or reviewed trading or other ultra-low-latency platforms, this should be straightforward. Let me know your availability this week along with one example of a past interview or evaluation you have conducted in a comparable domain.

Skills: C Programming, Python, Electronics, Technical Writing, Electrical Engineering, Software Development, Interviewing, Zoom

My C#-based desktop trading front end now needs a direct, real-time link to Sterling Trader Pro. The goal is full API integration that goes beyond a simple data feed: live quotes and depth, every order type Sterling supports, position & risk updates, plus a back-testing harness on the same codebase so strategies can run historically before they trade live.

The current application is stable and well-structured; what is missing is the Sterling layer—authentication, session management, event handling, and the conversion of our existing order objects to Sterling’s message format. All work must remain in C# and respect Sterling’s API guidelines.

Deliverables
• Connection module that authenticates and maintains a persistent Sterling session
• Real-time market data stream wired to our existing UI models
• Order router handling market, limit, stop, synthetic, and algo orders, with callbacks for partials, cancels, rejects, and fills
• Risk/position synchronization pulled from Sterling at configurable intervals
• Back-testing wrapper that reuses the same order/execution code path against historical data sets
• Brief setup document and commented code for internal maintenance

Acceptance Criteria
• End-to-end execution tested on Sterling’s demo environment with sample strategies
• Latency under 100 ms round-trip for market orders on a local connection
• All API exceptions caught and logged without crashing the host application

If you have previous Sterling Trader Pro experience—or deep familiarity with similar broker APIs—this should be a straightforward but rewarding integration project.

Skills: PHP, C# Programming, Software Architecture, C++ Programming, Software Development, Backend Development, API Development, API Integration

We have active requirements for production-grade software codebases for acquisition/licensing.
:small_blue_diamond: Required Technology Stacks

COBOL, Fortran, RPG
.NET Framework / Legacy C#
VB6
Java 7 & Earlier
C / C++
Go, Rust, Ruby
Swift, Kotlin
:small_blue_diamond: Legacy Codebases
We are looking for long-lived enterprise software with real development history, business logic, maintenance, PRs/issues, and testing activity.
Preferred:

Private repositories
Multi-year/decade development history
Enterprise/business-critical applications
Legacy migration projects
Production/deployed systems
:small_blue_diamond: Automotive / Vehicle Codebases
We are also looking for production-grade projects in:

ECU / Firmware
Telematics / Connected Vehicles
Vehicle Security / Immobilizer
Vehicle Control
ADAS
Diagnostics
Other automotive software
Preferred languages: C, C++, Rust
Operational data such as vehicle logs, telemetry, testing data, and diagnostic logs is also of interest.

Please Share Metadata

Project name & brief description
Technology/stack
Business domain
Repository age
Approx. LOC
Production status
Development history / PRs / Issues
IP & ownership rights
Availability of related datasets/data
Expected price


No open-source, demo, POC, tutorial, student, or small/sample projects.
Please share only genuine, production-grade and legally transferable/licensable codebases

Skills: C Programming, Java, .NET, C# Programming, COBOL, Fortran, C++ Programming, Rust

I want a robust .NET application that lets Microsoft Dynamics 365 Business Central talk to our Monri payment terminal in real time. Every sale or refund entered in Business Central should instantly trigger the same action on the terminal, return an approval or decline, and then write the response back to Dynamics so we can generate accurate transaction reports on demand.

Because the solution will be used by store staff, it needs a straightforward graphical interface—nothing fancy, just clear fields for transaction details, live status messages, and an area where users can pull a day-end report. Under the hood I expect solid error handling, logging, and an easy way to adjust endpoint settings without having to recompile.

Please build in clean, well-documented C# code (I work mainly with .NET 6+ and would like to keep that stack) and package the finished app with a simple installer plus source in a Git repo. Once this first connector is stable, I’ll commission several similar integrations, so I’m looking for someone who wants an ongoing partnership and can keep improving the product line as new payment devices or ERP updates appear.

If this sounds like a good fit, let me know how you would approach the real-time handshake with Monri, your preferred GUI framework, and any previous experience you have integrating with Business Central APIs.

Skills: .NET, C# Programming, Software Architecture, C++ Programming, Software Documentation, Graphical User Interface (GUI), Business Central, API Integration

I need a clean, modern website that lets visitors browse my residential listings with ease. The site’s sole purpose is to showcase properties, so every page should keep photos and details front-and-center while encouraging enquiries.

Key elements I must have:
• Property pages with a fast-loading photo gallery
• Seamless virtual-tour integration (YouTube, Matterport, or similar)
• A simple contact form on each listing that sends leads straight to my inbox

Please build the site to be mobile-friendly, search-engine aware, and easy for me to update with new homes later—WordPress, Webflow, or another user-friendly CMS is fine as long as the end result looks polished and loads quickly.

Hand-over will include all source files, login credentials, and a short walkthrough so I can add future properties myself.

Skills: Java, JavaScript, Python, Website Design, CSS, C++ Programming, HTML, Web Development, Web Application, Web Design

I’m developing an original 3v3 arcade street-basketball game and I’m looking for an experienced Unreal Engine developer to build the first playable gameplay prototype.

The goal is fast, physical, responsive basketball with a modernized PS2-era arcade streetball feel. The visual direction takes inspiration from the energy and attitude of early-2000s street-basketball games, while the controls and gameplay should feel smooth and modern.

This is NOT the full game. The purpose of this contract is to prove that the core basketball gameplay is fun before moving into full production.

PROTOTYPE REQUIREMENTS

• Third-person player movement
• Gamepad/controller support
• Ball possession system
• Basic dribbling and crossover mechanics
• Passing and catching
• Shooting/timing system
• Contested and uncontested shots
• Layups and basic dunks
• Rebounds
• Steals
• Blocks
• Loose-ball behavior
• Functional 3v3 teammate/opponent AI
• Offensive spacing
• Defensive positioning and switching
• Basketball scoring
• First-to-21 rules
• Possession/reset/check-ball logic
• Simple scoreboard
• Win/loss/restart functionality

VISUAL DIRECTION

The final game will use a gritty, stylized, modernized PS2-era street-basketball aesthetic.

This does NOT mean the gameplay should feel old or clunky. Movement, dribbling, passing, shooting and defense should feel responsive and satisfying on a controller.

Placeholder characters, animations and a basic basketball court are acceptable for this prototype. Gameplay comes first.

NOT REQUIRED FOR THIS PROTOTYPE

• Story mode
• Final character models
• Character creator
• Online multiplayer
• Fighting system
• Cinematics
• Large/polished environments
• Final artwork or UI
• Final soundtrack

Please do not include these features in your estimate.

TECHNICAL

Engine: Unreal Engine
Platform: Windows PC
Gameplay: 3v3 arcade street basketball
Budget: Approximately $900 fixed-price
Development: Milestone-based

PROPOSED MILESTONES

M1 – Core Movement & Dribbling — $150
Movement, camera, controller support, ball possession and basic dribbling/crossover.

M2 – Passing & Shooting — $150
Passing/catching, shooting, shot timing, makes/misses and basic shot contests.

M3 – Paint Gameplay — $175
Layups, basic dunks, rebounds, blocks, steals and loose balls.

M4 – 3v3 AI — $225
Functional 3v3 AI, offensive spacing, teammate behavior, defensive positioning and switching.

M5 – Rules & Game Loop — $100
First-to-21 scoring, possession/reset/check-ball rules, scoreboard, win/loss and restart.

M6 – Polish & Delivery — $100
Bug fixes, controller/gameplay polish, packaged Windows build and complete Unreal Engine project/source files.

Milestone 1 is the initial gameplay test. I want to evaluate the movement, ball possession and dribbling before proceeding with the remaining milestones.

If the prototype is successful, there is potential for significantly more paid development work on the full game.

IMPORTANT

I need delivery of the complete Unreal Engine project/source files, not only a packaged executable.

Any third-party assets, plugins, marketplace systems, code or other dependencies must be disclosed and approved before being incorporated into the project.

All original work created specifically for this contract must be available for commercial use according to our final agreement.

WHEN APPLYING, PLEASE INCLUDE:

1. Examples of gameplay systems you’ve personally programmed.
2. Any sports, basketball, third-person controller or gameplay AI experience.
3. A brief explanation of how you would approach ball possession and dribbling in Unreal Engine.
4. Whether you can deliver the complete Unreal project/source files.
5. Your estimated timeline.
6. Confirmation that you’re comfortable working milestone-by-milestone.

Please begin your proposal with “3V3” so I know you read the full description.

I’m interested in finding a developer who could potentially continue working with me long-term if the prototype goes well.