Posted on

gSender 1.0 is now here. Simple and powerful control of GRBL CNCs.

Hi everyone, Chris here.

It’s not often I post here, most often it’s Andy or Kelly keeping y’all up to date on the status of things happening here at Sienci Labs Headquarters; I’m much more behind-the-scenes. Today I’ve come out of the woodwork for a very exciting and momentous announcement for us, the release of gSender 1.0.

Since much of gSenders development hasn’t made much of an appearance on the company blog, let me bring you up to speed on where this project started and what the release to 1.0 now means:


Back in 2016 when Andy and I first started Sienci Labs around our Mill One CNC, the range of free and paid g-code senders specific to operating hobby CNCs was surprising wide. Options like UGS and Candle were quite widely used and more were in active development at the time such as UGSPlatform, CNCjs, bCNC, and more. We were able to make a wide range of recommendations to our CNC users as well as made documentation around specifically UGS at the time since we felt it was the most intuitive to use.

Jumping to 2020 we’ve now got more machines in the wild then ever before. If you’re familiar with working at scale, you know that a 5% failure rate, for example, is very manageable when you’re working in the hundreds but starts to be more of a headache in the thousands. This is what we were starting to encounter with the g-code senders available at the time. And I’ll clarify, when I say “failure rate” this isn’t me saying that the software didn’t work. There were outlying bugs, quirks, and stable versions that were more stable than others; but what also stuck out was that many of the available options were made for more technically savvy people.

What were our options?

With more and more calls coming in, we could tell our users were getting confused with existing sender options. We heard questions about basic functions, confusion about behaviour, and one of the hardest things for us to hear was that our users were blaming the functionality and abilities of our CNCs in cases where we knew it was coming down to the sender. I remember personally dealing with situations of broken bits because of probing operations, or even a time I remember vividly where I helped someone out for a whole hour over the phone because he thought his file was visualizing correctly and we found that he’d just accidentally closed the visualization window within the sender.

I want to make it clear that I have the utmost respect and thanks for all those who took the time to make their own g-code senders for hobby use. These contributors to the hobby CNC community as a whole have taken the time to take what would otherwise be a personal project and have released it for the world to use. Not only that, but they continue to support updates, bug fixes, new features, and much more – all on their own time and out of the passion that they themselves have for CNC. But ultimately, the origin of these projects is what made me realize around that time that the goals of these open-source projects were never going to meet the goals that Andy and I have always had for the company: to make CNC routing fully accessible to the public. As long as open-source developers were at the helm, customization and a diverse range of features would take priority over UI design, streamlined use, and catering towards beginners by using more understandable language.

This left us with two options. Either we help fund an existing project or put more man-power toward it and get it moving in the direction we felt would be best for the next generation of g-code sender, or we begin making our own. I sent some emails around, and spoke with some other developers I knew and the consensus was that we’d go with the latter. Seeing as these projects were the ‘babies’ of each respective group of open-source developers, we felt it wouldn’t be our place to ask for more from people who wanted to do development on their own schedule, or try to push our vision onto others. Thus gSender was begun.

Goals and Principals of gSender

Starting ideation in October 2020, we began testing existing senders and outlined our core goals and design principals that we felt would guide development:


  • Act as new default machine interface / sender for LongMill customers (this means including all the functions and features that users are already used to from there existing sending options)
  • Supercharge our customers’ experience with their LongMill by streamlining / simplifying machine interaction and making even more machine operations easily available (a.k.a. nice-to-haves)
  • Keep design open for use by other hobby CNCers to provide benefit outside of just our own community (this means leaving some wiggle room for broader customization and adaptability to other CNC machines on the market as well as even further advanced features)


  • If it’s set once it doesn’t need to be visible 100% of the time
  • Options most users don’t need should not be obvious or take up much screen real estate
  • Most actions should be 1 click
  • “Someone off the street should be able to figure out how to get started”
  • Order of widgets should be close to order of operations/steps to proceed
  • Machine state should be obvious at a glance
  • Use colour patterns to subconsciously communicate button functions
  • Substitute CNC jargon with simple language when possible

We knew the other primary holes we wanted to fill roughly included:

  • Easy interface for beginners yet advanced features available for more experienced hobbyists
  • Smart handling of error cases, probing, jogging, firmware editing, machine connection, etc.
  • Built-in tools for convenient CNC management: stock/wasteboard flattening, motor calibration, machine squaring, etc.
  • Extensive keymapping and built-in joystick compatibility
  • Support of tool changing, start/stop g-code, macros, coding variables

The idea was to branch off of the well-known and provably reliable open-source codebase so we could be confident that we were starting with a good foundation to build off of. We also wanted the software to be made available easily for all systems so that future implementations could support standalone machines. After a wide range of tests performed over many weeks, CNCjs’ codebase was chosen for the previous reasons and because testing showed reliable operation on a variety of computer systems.

Present Day Release

I’m very excited to announce that gSender 1.0 is now available for free to anyone who wants it!

After nearly a year in development, the first couple months being in Alpha and the remaining ones being in BETA, we’ve now become confident enough to declare our first reliable version. We’re really excited to see more people begin to use it as we’ve now got a whole swath of great features and about 2000 users using it to run jobs every day.

Some things that you can expect from gSender in its current state:

  • Reliability of operation
  • Accommodates a wide range of computing systems via its ‘Lightweight mode’
  • Easy to understand and use due to its interface layout
  • Takes care of a lot of complexities behind the scenes, making mistakes and errors less likely and easier to deal with when they do happen
  • Built-in tools for surfacing, machine calibration, firmware editing
  • Ability to ‘start from line’, tool change, run custom macros, quick-travel with limit switches, and much more

If you’d like to learn more, we’ve got a primary download page, a documentation area, our full Github page, a discussion forum, and even though we’ve reached 1.0 we’ll still be releasing new dev builds for the foreseeable future as we continue development on gSender:

Download here:

The team and I are very excited that we’ve reached this point. We set out to make our very own open-source and FREE g-code sender after gaining inspiration from some of the other commonly available options and we feel we’ve made a strong start towards those goals. To get here we owe a huge amount of thanks to our original 10 Alpha testers (you know who you are 😉 ), all those who participated in BETA testing and sending us suggestions and feedback, and importantly our greatest thanks to Will Winder and Cheton Wu for driving the UGS and CNCjs projects that not only were there for our initial users but also acted as a indispensable step towards us embarking on this project ourselves.

We want gSender to be the next-level open-source sender that’s available for all green CNCers to turn to whether they own a LongMill or otherwise: guided and easy to approach as a beginner yet customizable and feature-rich for higher-tier hobby CNCers. This means that it not only works for our Mill One and LongMill CNCs, but has already been proven to work on other machines like X-Carve, Shapeoko, Bob’s CNC, 3018, PROVer, and many more!

If you’re interested, the full list of features up to this point is as follows 😀 :

  • GRBL controllers supported
  • Smart machine connection
  • 3-axis digital readout (DRO) with manual value entry
  • All-directional jogging with XY diagonals, jog presets, and incremental/continuous single-button handling
  • Zero-setting and gotos (independent and combined)
  • Probing in any direction plus safe continuity detection ensures no broken cutting tools
  • Full imperial/metric compatibility
  • Responsive screen design and workspace customizations including visualizer light and dark theme
  • 3D toolpath visualization (no machine connection required)
  • File insight on load (feed range, spindle range, tools used, estimated cutting time, and overall, max, and min dimensions)
  • Feed override and active job status indicators
  • Fully exposed keyboard shortcuts for external keyboard/keypad control
  • Joystick support built-in for a variety of controllers
  • Safe height movements – accommodates machines with or without endstops
  • Homing cycle and quick-movement locations available for machines with homing hardware
  • Full spindle/laser support via manual control widgets, active alerting, and live overrides
  • Full mist/flood coolant support via manual control widgets and active alerting
  • Macros buttons (rearrangeable) with enhanced macro variables and individually assignable keyboard shortcuts
  • Lightweight mode reduces processing intensity on less powerful hardware or when running larger files
  • Easy workspace swapping for more advanced jigging or alignment work
  • Optional automatic handling for common error throwing g-code
  • Firmware tool for easier GRBL EEPROM changes, loading defaults, and GRBL flashing
  • Surfacing tool auto-generates surfacing g-code based on machine cutting area and other preferences, ready to execute
  • Calibration tool for axis alignment – a step by step process to make sure your CNC is square
  • Movement tuning tool for calibrating motor axis movements
  • Tool change functionality – pause, ignore, or run code blocks on M6 commands
  • Start-from-line functionality to resume jobs part-way through in case of failure of abort
  • Outline functionality indicates the rough bounds of the job before cutting
  • Customizable g-code injection at job start & end
  • Tooltips for data entry points
  • Alarm warning explanations to better contextualize CNC errors
  • Sleep management to keep PC awake during g-code sending
  • Pre-built machine profiles, including: LongMill
    • Shapeoko
    • X-carve
    • OpenBuilds CNCs
    • 3018 CNC & PROVer
    • BobsCNC CNCs
    • CNC4Newbie CNCs
    • Mill Right CNCs
    • Ooznest WorkBee
    • Nomad
    • Carvey
    • Mill One, and more…

What’s the plan moving forward?

Even though we’ll be taking a quick breather after release of 1.0, we’ll still be working toward even more features into the coming future. Some of these will include:

  • Headless Pi operation
  • Surface probing and other ‘fancier’ probing types
  • Built-in g-code editing
  • 3D cutting visualization

We left these off to the side ‘till now since we know that many of them would be more appealing to the more advanced users, but we’re confident that with everything currently built-in it’ll satisfy the vast majority of y’all.

Whatever comes next, we’ll be developing in two distinct branches. One that is for stable releases only, and another that you can optionally follow if you’re okay with a little less reliability but are wanting to be a part of shaping the new features that come to gSender.


It’s been great to spill this story out to y’all, there’s been a lot going on behind the scenes here at Sienci Labs this past year and I’m excited for you all to not only get more out of your machines via gSender but also via some more upcoming projects that we’ll be announcing in the coming months. Cheers everyone!