Zephyr & LVGL C Dev Needed for Smartwatch

@MuhammadUzair16

Hi I am an embedded systems engineer with over 16 years of experience. I have extensive experience building production C firmware with Zephyr and LVGL, including round displays, gesture-driven UI architecture, native simulation, and lifecycle-safe screen switching. One open-source watch platform absent from your list is Watchy. Its home is an e-paper watchface, with a physical MENU action exposing a hierarchical text menu. UP/DOWN moves through choices, SELECT drills in, and BACK retreats, creating a deterministic tree rather than sheets, cards, grids, planes, or rings. I propose one proven shape—a Watchy-inspired menu tree—and four original models: Timeline Now, Split Focus, Inbox Triage, and History Trail. Together they add hierarchical, temporal, dual-context, decision-flow, and reversible-path mental models, giving the AI meaningful structural choices. After repo access, I will compare their exact maps against all fifteen existing implementations before locking each milestone. I will deliver one model per milestone, following the existing C style and reusing shell verbs/views where suitable. I will validate clean builds, full gesture/tap/hold reachability, reliable return-home paths, 454x454 native_sim behavior, repeated model switching, and stable LVGL object counts, with the requested screenshots and behavior pages. My relevant embedded UI projects cannot be shared publicly due to client confidentiality, but I can show LVGL work privately under NDA. My bid is $1,500 for 14 days across five acceptance milestones. Please contact me to discuss details.

@Microlent

Hello, I am Dr. Rajesh Rolen, PhD in Computer Science & Engineering, with experience of over 20+ years in Software Development, UI / User Interface, Programming, Software Engineering, User Interface / IA As a preferred freelancer in the top 1%, I have done 400+ projects here on freelancer.com, I have 4.9 ratings out of 5 on average, which showcases my quality of work and timely delivery. Key Highlights: - Free Hosting Support on the Cloud or any desired platform. - Free 3 months of post-delivery support to ensure that our client doesn’t face any challenges after the launch of the project. - Free Dedicated tester on projects to ensure quality delivery, so clients don’t need to act as a tester. - 10+ Years experience UI/UX team to ensure intuitive UI. Portfolio: https://www.freelancer.com/u/Microlent Please open the chat and send me a message, so we can have a more detailed discussion about the project to give you the project timeline and cost. Thank you for considering my services. I look forward to engaging in a productive conversation and understanding how I can be of assistance in bringing your project to life. Regards Rajesh Rolen

@corpmember29

Hello,Please send the NDA copy to sign it , ZEPHYR & LVGL SMARTWATCH OS {{{ I HAVE BUILT SIMILAR EMBEDDED UI WORK AND CAN SHOW YOU RELEVANT WORK }}} I have 11+ years of software development experience, including C/C++, embedded UI development, Zephyr-based systems, and LVGL. I understand this is OS navigation architecture work rather than driver development, and I can work entirely with your native_sim environment. I can implement all 5 models directly against your arc_os_t contract, reusing existing shell verbs and views wherever possible. Each model will have a genuinely distinct home and gesture/navigation map, with defined tap/hold behavior, no dead ends, and every destination reachable through a readable list. I will also handle any genuinely required LVGL views within your existing visual language, native_sim screenshots, one-page navigation documentation per model, clean patch/branch delivery, and regression testing across all 20 models for repeated switching, crashes, warnings, and object-growth issues. For the five models, I can propose a mix of proven smartwatch interaction patterns not present in your existing 15 plus a few original navigation concepts, while keeping them consistent with your architecture. I WILL PROVIDE 2 YEARS OF FREE ONGOING SUPPORT AND COMPLETE SOURCE CODE. Thanks, Christina

@softsolution2000

I am a skilled C programmer with experience in UI architecture work using Zephyr and LVGL. I understand the importance of creating unique navigation models for a smartwatch OS and the impact it has on the user experience. I am confident in my ability to deliver five new operating system models that meet the specified requirements and quality standards. I have previous experience working on embedded UI projects and can provide examples of my work upon request. I am committed to meeting the project milestones and delivering high-quality results within the specified timeline. See the above links please.

@PINESCRIPTERR

Hi, I propose one proven model inspired by **wasp-os**, plus four original models after reviewing your existing fifteen. Wasp-os uses the watchface as home, left/right gestures to rotate through a curated quick-app ring, and swipe-up to open the complete launcher. This hybrid “quick ring + full directory” topology differs from a simple peer line or app-grid home. I’ll implement each model in C using the existing `arc_os_t` contract and shell verbs, with complete gesture coverage, guaranteed return paths, and careful LVGL object lifecycle management. Each model will be validated in `native_sim` at 454×454, including clean builds, repeated model-switch testing, screenshots, and navigation documentation. Embedded/LVGL work: **[insert portfolio link]** Three technical questions: 1. Does `arc_shell_home_set()` destroy the previous LVGL object tree, or must each model explicitly release its objects and callbacks? 2. Is there an existing test harness for injecting every `arc_dir_t`, tap, and hold event in `native_sim`? 3. Can you share the existing model table and screenshot tooling so navigation uniqueness and object-count baselines can be verified? Best regards, Houssame

@mayr81

I can add five genuinely distinct Zephyr+LVGL arc_os_t navigation models for the 454x454 MintWatch OS (native_sim to target builds), without touching your look-table scope. I’ll implement each model as one C table row plus the required start/gesture/tap/hold functions using your existing shell verbs and view constructors, and I’ll reuse existing widgets where permitted so we avoid crashes, dead ends, and unhandled directions. Each model will also be discoverable via the list row it belongs to, and I’ll ensure every reachable screen returns home. I’ll propose homes and gesture maps that do not duplicate any of the fifteen existing shapes, and I’ll verify the “three passes, no growth in allocated objects” constraint by running clean native_sim cycles and watching for warnings/regressions. Deliverables will include per-model documentation (home, 4 directions, tap/hold behavior, and a brief “not one of the fifteen” rationale), and a patch/branch that applies cleanly. I’ll generate screenshots with your repo screenshot tool for every home and reachable screen.

@rbtech1984

Hello!! The project needs five genuinely different smartwatch navigation models in the existing Zephyr and LVGL C architecture, with clean native_sim builds, defined gesture behaviour, no dead ends, screenshots and regression-safe switching. For the navigation model, a Pebble-style timeline approach could be adapted: the home shows the current context with vertically ordered information, while gestures move through adjacent timeline items and tap opens the selected item. This gives a distinct navigation model without adding unnecessary views. * Which five proposed navigation concepts do you prefer to review first? * Can you share the existing repository structure and model examples? * Should all five models be completed within the stated 14 days? Each model will follow the existing C table and shell architecture, reuse views wherever possible and include clean builds, gesture coverage, screenshots and switching tests. No driver or hardware bring-up will be introduced. Relevant embedded C, firmware, UI architecture and real-time interface projects have been handled with focus on stable behaviour and maintainable code. A milestone-based approach will keep every model independently reviewable. Happy to discuss the repository and proposed models. Best regards Farhin B

@tshibsamuel477

Hi there, I carefully read the full MintWatch specification and understand that this is **navigation-architecture work**, not theming or hardware bring-up. I can implement five genuinely distinct `arc_os_t` models in C using your existing Zephyr/LVGL shell verbs and views, with particular attention to deterministic navigation, clean model switching, LVGL object lifetime, and zero dead ends. I have worked with C/C++, embedded UI architectures, LVGL-style interfaces, event-driven systems, and resource-constrained embedded platforms, and I can work directly against `native_sim` before validating each model against your acceptance tests. I would also provide the required screenshots and one-page behavioral documentation for every model. I’m comfortable working under NDA and assigning the completed work as required. Send me a message with repository access and I can start immediately. Relevant embedded UI work: I can share applicable examples privately with the project owner. Best regards, Samuel tshibangu

@hayteekeys

HI, KINDLY READ THROUGH MY PROPOSAL I will implement five genuinely distinct navigation models for MintWatch (Zephyr + LVGL) that follow the exact `arc_os_t` contract, reuse existing shell verbs and views where appropriate, and meet the strict behavioural reliability requirements. MY APPROACH ✅ Design five different home + gesture models that are not duplicates of the existing fifteen ✅ Implement each model against the provided C table structure using existing shell verbs ✅ Ensure every gesture has a defined result, every destination can return home, and all screens are reachable by reading ✅ Validate clean builds, native_sim 454×454 operation, and stable multi-model switching with no memory growth Example of a different navigation model Samsung Galaxy Watch (One UI Watch / Wear OS) DELIVERABLES - Five models implemented in the existing C style - Any new views required (strictly within the defined visual language) - Screenshots of each model’s home and reachable screens - One-page description per model - Clean patch/branch that applies to the repository Commercial Fixed-price, milestone-based (one payment per accepted model). Timeline and price to be confirmed after repository access and review of the existing codebase. QUESTIONS 1. Can repository access and NDA be provided upon award? 2. Are there any preferred directions or constraints for the five new models beyond being genuinely different? Ready to start once access is granted.

@tyronet2

You need five navigation systems that remain behaviorally distinct, memory-stable, and fully reversible across every gesture—not five visual variations. I propose a Garmin-style glance loop as one model. Its home remains the watchface; up/down enters and traverses compact widget previews, tap expands one view, and back collapses to the same position. I would first map all 15 existing models to prevent structural overlap, then implement each new row and static handlers in the project’s current C style. Every model will define four directions, tap, hold, readable list access, and a guaranteed route home. I’ll validate pristine Zephyr builds, native_sim behavior at 454×454, three 20-model switching passes, object counts, and repository-generated screenshots. Deliverables include five clean milestones, one-page behavior maps, and an applicable branch. Fixed price: $2,500. Delivery: 14 days. Embedded UI sample

@AlexandrGergel

Hi, I’m interested in this project because it is not just about UI design. The main work is about navigation logic, screen flow, and making sure every action is safe and predictable. I’m a senior embedded software engineer with more than 9 years of experience in C/C++, RTOS, and embedded systems. For this project, I would first study the existing 15 models and understand how each one works. Then I would design five new models with different home screens and different navigation logic, not just different visual styles. One open-source smartwatch OS I like is ZSWatch. It is based on Zephyr and LVGL and can also run in a simulator without hardware. Its home is a watchface, and the user can move to the app list and other screens through touch gestures. It also has clear back navigation, which is important for avoiding dead ends. I think ZSWatch is a good reference for this project because it uses a similar technical stack and also needs good control of screen lifecycle and LVGL objects. I would use it only as a reference and would not copy its UI or navigation model. For MintWatch, I would treat every model as a small state machine. Every swipe direction, tap, and hold action would have a defined result. Every screen would have a clear way to return home. I would also make sure that screens are properly cleaned up when switching models so there is no memory growth. I propose $1500 in 10 days. Best, Oleksandr

@julianm260

I understand the full scope of your project and I'm confident that my strong background in C programming and embedded systems aligns perfectly with your needs. With over 8 years in RF engineering and extensive experience in firmware development, I'm adept at efficiently translating complex specifications into functional, reliable code. One of my strengths is my ability to carry projects from inception to final implementation using a meticulous process that includes design, simulation, validation, documentation, and final implementation - all while adhering strictly to safety and performance standards. This approach will be invaluable for your project as it not only involves bringing new models to life, but also ensuring they are seamlessly integrated into the existing system. What sets me apart is my unshakable commitment to delivering high-quality results under tight deadlines. I understand your project requires absolute precision since these models form the foundation of your OS' AI generation process. They're not just different themes, but entirely disparate operating systems and any glitch can affect your customers. I assure you that every gesture from home will have a defined result, every destination will return home, and we'll avoid dead-ends or unhandled directions for the best user experience possible. Let’s collaborate to build exceptional navigation models for your smartwatch!

@manishSuryaR

Hello! Bravion from Cleveland here. For the external navigation model not in your fifteen: Garmin CIQ Widget Glances with Long-Press Deep Linking. Home is a condensed, continuously scrollable vertical list of live data summaries rather than full-screen cards or sheets, where each item updates in place; swiping vertically browses summaries, tapping any glance drills into a full-screen dedicated sub-app, and holding the back gesture returns directly home while a long press from home jumps straight into system control dials. My proposed set of five distinct models for MintWatch: Garmin-style Glances: Vertical glance-list home with tap drill-downs and swipe-to-pop. Concentric Polar Orbital: Home is an analog ring dial; swiping cardinal directions expands distinct nested orbital bands that rotate via swipe and collapse on tap. Radial Sector Bloom: Home is a dense text clock; holding blooms four diagonal interactive sectors, and swiping collapses the opposite quadrant into focus. Timeline/Logbook Stream: Home is a chronologically ordered vertical event feed; horizontal swipes expand the highlighted entry into detail or action modes. Dual-Axis Cross Matrix: Home is a minimalist split-screen intersection; horizontal navigation cycles primary domains while vertical navigation steps through contextual sub-states of the active domain. Let's make the project a success together.

@hussainmuzammal4

Hi,What is your biggest worry about this project? Zephyr & LVGL C Dev Needed for Smartwatch This is Muzammal Hussain thank you for posting your project details,Lets share value together. Best Regards

@jaroslavcaprata

Hello! I work with embedded C, event-driven UI architecture, state-safe navigation, and small-screen interfaces. I understand that these five deliverables are operating-system models with distinct home states and gesture maps—not visual themes. One shipping model I would draw from is Garmin’s Glance Loop. The watchface is home; up and down traverse an ordered circular loop of compact data summaries, while tap drills into the selected function and back returns through the same hierarchy. It differs from cards over a face or a ranked single-card model because navigation is a stable, bidirectional summary-to-detail loop rather than overlays or priority selection. For MintWatch, I would first map all fifteen existing models, then define five non-overlapping state graphs. Each implementation would use the existing shell verbs and views wherever possible, with explicit handling for four directions, tap, hold, readable list access, and deterministic return-home paths. I will validate pristine Zephyr builds, native_sim behaviour at 454×454, repeated twenty-model switching, object-count stability, screenshots, and one-page model documentation. Can you share the existing model table and shell/view APIs after NDA signing? Thanks

@hayat38402

Hello, I am Muhammad Javed, an Embedded/Software Engineer with more than 10 years of experience in C, embedded UI development, Zephyr, and LVGL. I have studied the complete requirements, and this project exactly matches my expertise in resource-constrained UI architecture. One open-source watch OS I would reference is AsteroidOS, whose interaction is based around an application-oriented launcher and vertically navigated views rather than the grid, carousel, sheets, or panel models in your existing fifteen. I can use proven concepts where useful while also creating original navigation models that are genuinely distinct. I will implement all five models against your arc_os_t contract, reusing existing shell verbs and views wherever possible and adding only necessary LVGL views. Every direction, tap and hold will have a defined result, every destination will return home, and every new screen will be reachable through a list. I will validate pristine builds with no new warnings, native_sim at 454x454, all navigation paths, repeated switching across all twenty models, crash/hang prevention, and allocated-object stability. I will also provide screenshots, one-page documentation per model, and a clean patch/branch. I am comfortable working entirely in native_sim without hardware bring-up. Relevant embedded/LVGL work and portfolio links can be provided with my bid. Price: $1,250 fixed | Schedule: 14 days | 5 milestones

@KarthikTechCon

Bid Proposal by Karthik Hello, I am Karthik, a C developer with over 15 years of experience, specializing in UI architecture and embedded systems. I am excited about the opportunity to develop five unique navigation models for your MintWatch OS using Zephyr and LVGL. Proposed Model: I suggest implementing a navigation model inspired by the "WearOS" system. Its home interface features a customizable watch face with gesture-based navigation: swipe left for widgets, right for notifications, up for apps, and down for quick settings. This provides users with an intuitive and fluid experience. Experience: I have extensive experience with embedded UI development, including LVGL. Price & Timeline: I propose a budget of $1,200 for the entire project, with a delivery timeline of 14 days. Each model will be developed with a focus on stability and performance, ensuring no crashes or dead ends. Looking forward to collaborating on this innovative project! Best, Karthik

@ayesha86664

Hi there! MintWatch needs five navigation models that are truly different, safe to switch between, and reliable on native_sim. The main challenge is defining every gesture and return path without crashes, dead ends, or object growth. I have experience with C, embedded UI, LVGL, Zephyr, and firmware-focused interface work. For the open source reference, I would propose AsteroidOS: its home is centered around a watchface with app-oriented navigation, while gestures and swipes move between watch functions and applications in a different way from the fifteen models listed. I will study the existing architecture first and add each model using the same arc_os_t contract and existing shell verbs. I will test all directions, tap and hold actions, navigation back home, list discoverability, clean builds, screenshots, and repeated switching on native_sim. I can deliver the five milestones within 14 days. check our work https://www.freelancer.com/u/ayesha86664 Can you share the current model file so I can align the implementation with its exact C style? Let me know if you’re interested & we can discuss it. Best Regards Ayesha

@emilesd617

A navigation model I’d propose studying is "Garmin’s glance-based watch UI". The home remains the watch face, while vertical navigation moves through a continuous sequence of glanceable information surfaces rather than opening independent edge sheets or an app grid; selecting a glance drills into that function, with a consistent return path back to the glance loop and home. For MintWatch, I’d implement five models directly against your existing `arc_os_t` contract and reuse the current shell verbs/views wherever possible. My focus would be behavioral correctness first: every direction defined, no stranded screens, alternate list-based access to destinations, clean repeated model switching, and no LVGL object growth. I’m comfortable working in C with Zephyr-style RTOS architecture and LVGL UI state/navigation. Thanks. Emile.