grid.space No paid content found

CNC stands for computer numerical control: a computer (the CNC controller) reads a part program and commands motors to move a machine tool along precise paths, so parts are cut, drilled, turned, or shaped repeatably instead of by hand. It applies to almost any machine that removes material or moves a tool under programmed control — mills, lathes, EDM machines, routers, and more. FANUC's role in this picture is specific: it supplies CNC controls, drives, motors, and its own compact machine series (ROBOMACHINE), while independent machine builders integrate FANUC controls into their own machines.

How a CNC machine works

The chain from drawing to finished part runs through four stages:

1. Part program — a human or CAM software produces instructions. In the most common form this is G-code: a text list of coordinates, feed rates, spindle speeds, and tool changes.
2. Controller — the CNC control reads the program, plans the toolpath, and calculates the motion each axis must make, moment by moment.
3. Drives and motors — servo drives convert the controller's commands into electrical power; servo motors turn that into shaft rotation or linear motion.
4. Feedback and machine tool — position sensors report actual axis position back to the control, which corrects any error. The machine tool itself (spindle, slides, table, tool changer) is what actually contacts the workpiece.

The controller is the part that makes the machine "CNC" rather than manual. It closes the loop between commanded and actual position many times per second.

Main CNC machine types and what they are used for

The same control concepts apply across all of them; what changes is the machine structure and the process.

Core system components

• CNC controller — the interface and brain: program storage, motion planning, operator display.
• Servo drives — power amplifiers matched to each axis and spindle.
• Servo motors — execute the commanded motion.
• Feedback devices — encoders or scales that report real position.
• Machine tool — the mechanical structure that holds and moves the tool and workpiece.

A control is only as good as the machine it is mounted on, which is why the control supplier and the machine builder are usually different companies.

Where FANUC fits

FANUC is a supplier of factory automation and robotics, and its product range includes CNC controls alongside robots, ROBOMACHINE, ROBODRILL, ROBOSHOT, ROBOCUT, ROBONANO, and laser products. Two distinctions matter when reading about CNC:

• As a CNC control supplier — FANUC provides the controller, drives, motors, and related CNC technology that machine tool builders integrate into their machines. When you see "FANUC control" on a mill or lathe, FANUC supplied the control side, not necessarily the whole machine.
• As a machine supplier — under the ROBOMACHINE name, FANUC also offers its own compact CNC machine series. So FANUC appears both as the control inside other builders' machines and as the maker of complete machines.

This is why "FANUC CNC" can mean either the control unit or a FANUC-built machine, depending on context.

Programming inputs you will encounter

• G-code — the standard low-level instruction set for motion, feeds, speeds, and tool changes.
• CAM output — software that converts a CAD model into G-code, often for complex 3D shapes.
• Conversational programming — control-side interfaces that let an operator build a program from menus and graphics instead of typing G-code.

For simple parts, hand-written G-code is common. For contoured 3D work, CAM-generated code is the norm.

Practical next steps

• To learn CNC basics — start with G-code fundamentals (coordinate systems, feed and speed, tool length offsets) and run a simulation or a small desktop machine before touching production equipment.
• To select a control — decide first what machine type and part complexity you need, then check which control the machine builder offers and whether its programming style (G-code vs. conversational) matches your operators' skills.
• To understand a specific FANUC product — treat the control, the robot, and the ROBOMACHINE series as separate product lines, since each has its own documentation and application scope.

The key takeaway: CNC is the control layer that turns a program into precise machine motion, and FANUC occupies two positions in that chain — control technology supplier and, through ROBOMACHINE, machine supplier.

A web browser is the program that requests web pages from servers and turns their code into the readable, clickable pages you see. You use one whenever you open a site, follow a link, or log in somewhere. Choosing one comes down to a few practical factors — rendering engine, speed, memory use, privacy, sync, and extension support — and you can switch without losing your bookmarks or passwords if you export them first.

What a browser actually does

Two jobs matter most:

1. Fetching — when you enter an address or click a link, the browser sends a request to the site's server and receives the page's files (HTML, CSS, JavaScript, images).
2. Rendering — it interprets those files and draws the page: text, layout, images, and interactive elements.

Everything else in the interface sits on top of those two jobs.

The main parts of a browser interface

These are common across browsers, so the interface is rarely the deciding factor. What differs underneath is the rendering engine.

Rendering engines and why they matter

A rendering engine is the component that turns page code into what you see. Different engines can handle the same page differently, which affects compatibility and sometimes speed.

Avant Browser, for example, is described as a tri-core rendering browser that supports IE, Firefox, and Chrome engines. That means it can switch between engines rather than relying on just one. The practical reason to care: if a site behaves oddly in one engine, a browser that offers another engine gives you a fallback without installing a second program.

For most people, a single modern engine is fine. Multi-engine browsers are more relevant if you regularly hit sites that only work correctly in a specific engine.

Practical factors for choosing a browser

• Speed — how quickly pages load and respond. Hard to judge from marketing claims; test on the sites you actually use.
• Memory use — browsers with many tabs can consume a lot of RAM. Avant Browser's description specifically claims to be memory leak free, which targets the problem of memory use creeping up over long sessions.
• Privacy — what data is collected, how tracking is handled, and what controls you have.
• Sync — whether bookmarks, passwords, and history carry across your devices, and what account it requires.
• Extension support — whether the add-ons you depend on are available.
• Multi-process design — Avant Browser lists multi-process support, which typically means one tab crashing doesn't take down the whole browser.

Avant Browser also lists cloud storage among its features, which generally refers to keeping bookmarks or settings online so they're available across machines. Check the specific feature before relying on it.

How to try or switch browsers without losing your data

1. Export from your current browser. In settings, look for bookmark export (usually to an HTML file) and password export. Save both somewhere you can find them.
2. Install the new browser. Download it from the official site and run the installer.
3. Import your data. Most browsers offer an import option on first run or in settings that reads bookmarks from another browser or from an exported file.
4. Set your defaults. Choose your search engine, homepage, and whether to sync.
5. Verify before removing the old browser. Open a few bookmarked sites and confirm saved logins work. Keep the old browser installed until you're satisfied.
6. Reinstall essential extensions. Extensions usually don't transfer automatically, and some may not exist for the new browser.

Common snags: password export is sometimes locked behind a system password prompt; some browsers only import from a fixed list of other browsers, so an exported HTML file is the safer route; and extensions tied to one browser's store may have no equivalent elsewhere.

A quick way to decide

• If you want the widest site compatibility and don't mind one engine, a mainstream single-engine browser is the simplest choice.
• If you hit sites that only render correctly in a particular engine, a multi-engine browser like Avant Browser — which supports IE, Firefox, and Chrome engines — removes the need to keep several browsers installed.
• If long sessions with many tabs slow your machine down, prioritize memory behavior and multi-process support.
• If you work across multiple computers, check what sync or cloud storage the browser offers and whether it requires an account.

The fastest way to judge any of these is to install it, import your bookmarks, and use it for a few days on your normal sites.

A slicer is the software step that turns a 3D model or 2D image into machine instructions: per-layer paths for an FDM printer, exposure images for an SLA printer, or toolpaths for a CNC mill or laser cutter. Pick one by matching it to your machine type first, then to how you want to run it — installed on a desktop, or in a browser with no install and no account. Grid.Space's Kiri:Moto, for example, is a browser-based toolbox that handles 3D printing, CNC milling, and laser cutting, and runs entirely on your device with no cloud dependency.

What a slicer actually does

The name comes from FDM printing, where a solid model is cut into horizontal layers. The same job applies elsewhere:

• FDM: converts a mesh into per-layer extrusion paths, plus supports, infill, and travel moves.
• SLA: produces per-layer exposure images for a resin printer.
• CNC: generates toolpaths (roughing, finishing, drilling) from a model, with feeds, speeds, and stepover.
• Laser: converts 2D artwork or a sliced model into cut and engrave paths, including stacking for multiple passes.

In every case the output is a machine-readable file — G-code for FDM/CNC, a job file for laser, a layer archive for SLA — that the machine or its control software executes.

Match the slicer to the machine, not the other way around

The most common mistake is choosing a tool because it is popular, then discovering it does not support your process. Use the same dimensions when comparing options:

Kiri:Moto covers FDM/SLA printing, CNC toolpath generation, and laser cutting in one tool, and includes simple mesh editing and repair plus parametric CAD modeling. That breadth is unusual — most slicers specialize in one process.

Browser-based vs desktop vs cloud

This choice affects privacy, portability, and offline use more than print quality.

• Desktop install: full local control, but tied to one machine and needs updates and disk space.
• Cloud service: convenient from any device, but your models leave your computer and you usually need an account.
• Browser-based local: runs in the browser sandbox on your own device. Kiri:Moto states that all slicing and toolpath generation happen locally, with no installs, no accounts, and no cloud dependency, and that it works even offline.

Browser-local is the middle path: nothing to install, nothing uploaded. The trade-off is that performance depends on your device and browser rather than a dedicated workstation.

A practical first run

1. Import a 3D model or 2D image.
2. Choose the process — FDM, SLA, CNC, or laser — since this changes every downstream setting.
3. Set machine and material parameters: nozzle or tool diameter, layer height or stepover, speeds, and temperatures where relevant.
4. Slice or generate toolpaths, then preview layer by layer or path by path.
5. Fix what the preview shows — add supports, reorient the part, or repair the mesh.
6. Export the machine file and send it to the machine.

The preview is the verification step. If the preview looks wrong, the machine output will be wrong.

Common failure points

• Non-manifold or broken mesh: the slicer cannot decide what is inside or outside. Repair or boolean-fix the model first.
• Wrong scale: models often import in millimeters when authored in inches, or vice versa. Check dimensions against the real part.
• Missing or misplaced supports: overhangs fail without them; auto-supports sometimes need manual edits.
• Path anomalies in CNC or laser: wrong tool diameter, stepover, or feed settings produce gouges, burns, or broken bits.
• Machine rejects the file: usually a format or firmware mismatch — confirm the export format your controller expects.

Who should consider a browser slicer

If you work across a Chromebook, a shared computer, or several devices, a browser-based local slicer avoids installs and account juggling. Kiri:Moto has been in continuous development for over a decade, is fully open-source and free to use, and is aimed at makers, educators, and prosumers. If you need vendor-specific profiles, tight integration with one printer ecosystem, or heavy simulation, a dedicated desktop slicer may fit better. The deciding question is simple: does the tool support your machine type and let you verify the output before you commit material?

Cascadeur's site offers a free way to try the software and links to paid plans, but the public page does not spell out exactly what the free tier includes or where its limits sit. What it does confirm is the feature set — AI-assisted keyframe animation, AutoPosing, AutoPhysics, Ragdoll, Inbetweening, AI motion generation, rigging, retargeting, and UE Live Link — plus file compatibility with .FBX, .DAE, .GLB/.GLTF, and .USD. If you need a definitive free-vs-paid breakdown, treat the Plans page and the trial start as the two places to check, because the homepage itself doesn't publish export limits, watermark rules, or commercial-use terms.

What the public page actually tells you

The homepage positions Cascadeur as "the easiest way to animate" and invites you to "Try for free" or "Watch demo." It lists these capabilities without marking any as paid-only:

• Inbetweening — AI interpolation that generates motion between keyframes
• Ragdoll — procedural reactions to impacts, falls, and collisions
• AutoPosing — get natural poses by moving fewer control points
• Quadrupeds — rigging, AutoPosing, and one-click retargeting for four-legged animals
• AI Motion Generation — running, jumping, combat, acrobatics, idles, and more
• AutoPhysics — a character double showing a physically accurate result, for tuning secondary motion and inertia
• Rigging — drag-and-drop joints to auto-generate a rig for humanoids and quadrupeds
• Retargeting — copy/paste animation between characters regardless of skeleton or proportions
• UE Live Link — stream animation to Unreal Engine with real-time updates

It also names the solution areas: mocap cleanup, previz, animation editing, AI, video games, prototyping, and markerless mocap. Mocap cleanup is described as fixing foot sliding, knee pops, geometry penetration, poses via AutoPosing, weight via AutoPhysics, and edits via Animation Layers.

None of this is labeled "free" or "paid" on the page, so don't assume the list equals the free tier.

The two "free" paths are different things

The page shows two separate entry points, and mixing them up is the most common source of confusion:

The trial link points to cascadeur.com/plans#trial, which means trial terms live on the pricing page, not the homepage. If your decision depends on whether you can keep using it indefinitely at no cost, that answer has to come from the Plans page — the homepage doesn't provide it.

When the free route is likely enough

Based on the feature list alone, a free or trial route is worth starting with if you are:

• Learning the workflow — testing AutoPosing and Inbetweening on a simple humanoid before committing
• Evaluating mocap cleanup — checking whether the foot-sliding and knee-pop fixes fit your pipeline
• Prototyping — blocking previz or game animation without a production deadline
• Testing file compatibility — confirming your .FBX, .DAE, .GLB/.GLTF, or .USD assets import cleanly

When upgrading becomes the real question

Upgrade pressure usually comes from constraints the homepage doesn't state, so verify each against the Plans page before paying:

1. Export restrictions — if the free tier limits resolution, format, or adds a watermark, that alone can force an upgrade for client work.
2. Commercial use — confirm whether free-tier output can be used in shipped products. The page doesn't say.
3. Team or pipeline needs — UE Live Link and retargeting matter more in production; check whether they're gated.
4. Volume of work — a single test animation and a full game's combat set have very different tolerance for limits.

A concrete example: if you're cleaning up a markerless mocap take for a game prototype and the free route lets you fix foot sliding and apply AutoPhysics, you may never need to pay. If you're delivering that animation into a commercial build and the free tier restricts export or licensing, the upgrade decision is made for you by the terms, not the feature list.

How to decide without guessing

1. Open the Plans page and read the actual tier comparison — this is the only authoritative source in the material provided.
2. Start the trial and test the specific features your project needs: AutoPosing, AutoPhysics, Ragdoll, Inbetweening, retargeting, and UE Live Link.
3. Test an export end-to-end with your real file format (.FBX, .DAE, .GLB/.GLTF, or .USD) and inspect the output for watermarks or quality loss.
4. Check the commercial-use terms in writing before shipping anything.
5. Only then compare cost against the limits you actually hit.

The homepage is useful for understanding what Cascadeur does — AI-assisted keyframe animation for character work, mocap cleanup, and game pipelines. It is not a pricing document. For the free-vs-paid question specifically, the Plans page is the answer, and the trial is how you verify it against your own project.

Browser-based 3D printing means running the slicing step — turning a 3D model into machine instructions — inside a web browser tab instead of a desktop application. Tools like Kiri:Moto on grid.space do this with no installs, no accounts, and no cloud dependency: rendering, slicing, previews, and exports all happen locally in the browser sandbox. This works well for FDM/SLA printing, CNC toolpaths, and laser output on almost any device, including Chromebooks. The trade-off is that you depend on browser performance and memory rather than a dedicated desktop app, so very large or complex jobs may still be easier on a desktop slicer.

How browser-based slicing actually works

The key mechanism is local execution. Kiri:Moto describes itself as running "entirely on your device with no installs, no accounts, and no cloud dependency," with "all slicing and toolpath generation happen[ing] locally in your browser for maximum privacy and portability."

That means:

• Your model is not uploaded to a server for processing.
• Slicing and toolpath math run in the browser sandbox.
• It can work even offline, per the project's description.

This is different from a web app that uploads your file, slices it on a server, and sends G-code back. Here the browser is the engine, not just the interface.

Step-by-step: import, slice, preview, export

The exact menus depend on the tool, but the workflow for a browser slicer like Kiri:Moto follows this shape:

1. Open the slicer in your browser. No account or install is required for Kiri:Moto.
2. Import your model. Kiri:Moto accepts 3D models or 2D images. For printing you'll typically load an STL or similar mesh.
3. Choose your process. Kiri:Moto supports FDM/SLA printing, CNC toolpaths, and laser output — pick the one matching your machine.
4. Set your parameters. Layer height, infill, supports, and temperature for FDM; exposure and layer settings for SLA. These are the same categories a desktop slicer exposes.
5. Slice. The browser computes the toolpath locally. Expected result: a previewable set of layers and moves.
6. Preview. Check layer-by-layer visualization before committing material. Kiri:Moto includes live visualization.
7. Export. Generate the G-code (or laser/CNC output) and save it for your machine.

Verification: the preview should match your intended orientation, supports, and infill. If the preview looks wrong, fix the model or settings before exporting — don't print to find out.

Why local, in-browser processing matters

• Privacy: files stay on your device; nothing is uploaded for slicing.
• Portability: works on almost any device, including low-power laptops and Chromebooks, since there's nothing to install.
• No lock-in: Kiri:Moto is open-source and free to use, and the project frames itself as avoiding "proprietary lock-in and heavy desktop installs."
• Offline use: because processing is local, it can run without a network connection.

For schools, shared computers, and locked-down devices, this removes the usual install-and-admin-rights barrier.

Limitations and when a desktop slicer is still better

Browser slicing is not automatically the right choice for every job. Consider a desktop slicer when:

• Your models are very large or high-poly. Browser memory and CPU limits can bite where a desktop app with more resources won't.
• You need vendor-specific profiles or advanced tuning. Desktop slicers from printer makers often ship tuned presets for their hardware.
• You want deep plugin ecosystems. Mature desktop tools have broader extension support.
• You're offline on a device with no browser access — though Kiri:Moto is designed to work offline once loaded.

For everyday FDM/SLA parts, education, and quick iteration, browser slicing is usually enough. For production or highly tuned workflows, keep a desktop option in reserve.

Getting started with Kiri:Moto

Kiri:Moto is a browser-based toolbox for 3D printing, CNC milling, and laser cutting, in continuous development for over a decade. It's open-source and free to use, and the project invites users to report bugs, request features, create device profiles, or contribute code.

To start:

1. Open Kiri:Moto in your browser — no install, no account.
2. Import a model and select your process (print, CNC, or laser).
3. Slice, preview, and export.

If you're on a Chromebook or a machine where you can't install software, this is the most direct path to producing G-code. If you hit performance limits on a complex model, that's your signal to move the job to a desktop slicer.