Thank goodness they are revamping the UI. I imagine its overwhelming for newer user. Its a bit much atm.
@Gerrit “It would definitely help if BambuLabs would at least bring some limited experimental stuff into the slicer so users can play with it and give feedback.”
I wish, but people say it would make supplying support harder.
Uhhh… what?
It’s April 2026… all I wanted was to print the fillet areas of my part with the .2mm nozzle and the large sections with .4. I guess that’s not possible after the $3,600 I invested in this machine & accessories?
Interesting - what size are your fillets - <0.4mm? And are they on horizontal or vertical sections?
For horizontal sections - Are you expecting to use 0.2mm on the whole outer surface or just on the fillets - as if just on the fillets. Will there then be a joint where the nozzle sizes change.
Personally I’m mainly expecting to use 0.2mm for discreate features like ship railings, plus tiny text - although in that case I accept there might be a joint around the edge of the text area.
Maybe also whole top and bottom layers
I’m expecting to use different nozzle sizes for different layers, as that;s how I expect the system to work, when the firmware drops…….
I hope it doesn’t restrict nozzle sizes to whole layers - as personally I wan’t some parts of layers (probably mostly not connected to other parts on the same layer) to be done in a smaller nozzle - with the bulk of the layer done in a bigger nozzle.
Then you bought the right printer, because it’s not a limitation of the printer, but one of the slicer.
So now try to find a slicer that can do this.
I fully agree. It’s not impossible, but there are so many use cases that fulfilling all is far away. But they could start with simple parts like a different size for the top and or bottom layers.
OrclaSlicer has supported it since September 2024, and Prusa (on the XL) since December 2024, so it still being absent in July 2026 from Bambuslicer seems hard to defend.
Creality has been quite vocal in saying that K3 will support it when it releases (now expected sometime Q3 2026). Vorons have supported it for years now. Of concern, though, is that U1 still doesn’t support it. It uses an orcaslicer derivative, but Its firmware prohibits it. Why? Is there some kind of essential hardware it’s missing, and, if so, is Bambulab H-series also missing it?
I would say it will appear in Q3 with Bambu. Those heater mods on AMS came out and suddenly the same time the ability to dry filament while printing showed up. I like my H2D/C but I think Bambu is redoing how they use the nozzle changer with either a AMS 3 Pro or new printer with a full tool head changer. I think if they can just get the swaps fixed with a new AMS it would reduce changes enough to compete.
I don’t think it requires any hardware changes.
Maybe the High-Precision Nozzle Offset Calibration needs a firmware update to handle the different line widths coming from the different nozzle sizes.
Physically everything is in place.
Yeah it is curious that the multi nozzle sizes isn’t a thing yet, in any form, for bambustudio.
That it is showing up in other company’s slicers, even the orca derivatives, is real interesting.
There must be some deep conflict in their codebases otherwise why not just do a little research and pull it in? (Maybe they’re not very literate about the AGPL lol) likely stemming from all involved forks being very lovingly actively developed, and diverged what, 2-to-4 years ago? Maybe that creality one is newer.
You can find OrcaSlicer work on GitHub. LixNix (PR# 13782) shows the per-feature nozzle/filament assignment work to support multi-size nozzle printing (for the same part). I’m recommending a different approach:
Mixed Nozzle Diameters: A Fine-First, Band-Based Model
Prepared for consideration by the Bambu Lab engineering team
Note up front
Bambu’s own FAQ already states that mixed nozzle diameters are planned: “Currently, the firmware supports mixed flow-rate printing… but does not yet support mixing different nozzle sizes during printing. If this feature is added in the future, we will provide details through a software update.” This document isn’t a request that the feature exist — that’s already committed to. It’s a specific mechanism for how to do it correctly, offered in case it’s useful input while the design is still open. The mechanism itself only requires two-or-more-nozzle hardware — it applies to H2D/X2D’s independent-nozzle setup as much as to H2C’s Vortek rack — though as noted below, Vortek is particularly well-suited to it. If the internal design already covers this ground, most of what follows will be familiar; if any of it isn’t, it may save some iteration.
What hardware this needs, and where Vortek has a specific edge
The mechanism above needs only two things from the hardware: some way to bring more than one nozzle diameter to bear within a single job, and enough control over swap/Z-motion timing to enforce the fine-first, flush-boundary ordering. That’s satisfied by any of Bambu’s multi-nozzle platforms — H2D and X2D’s independently-mounted dual nozzles work by the same logic as Vortek’s hotend-swap rack, since the access constraint driving fine-first ordering (a nozzle’s widening cone can’t reach the base of an already-printed taller wall) applies identically regardless of how the second nozzle got into position.
Where Vortek specifically pulls ahead is color. Because each hotend stays pinned to one filament/diameter identity with no purge on swap, Vortek is the only current Bambu platform where diameter-splitting a color doesn’t reintroduce the flushing the swap system exists to avoid — H2D/X2D’s fixed dual-nozzle setup doesn’t have that slot flexibility, so multi-color plus diameter-splitting together is a Vortek-specific strength, covered in the color section below. For single-color or few-color jobs, any of the multi-nozzle platforms should support this model equally well.
There’s also a broader structural point worth naming: this is buildable correctly at the firmware/motion-planning level on any of Bambu’s own hardware, in a way no third-party slicer working around opaque firmware from outside — including OrcaSlicer’s current in-progress community effort — can fully replicate, since visibility into swap timing and Z-motion sequencing isn’t available to them.
The core reframe
Treat the entire print as defined at the finer of whatever two nozzle diameters are paired for a given job — that’s ground truth for quality in that pairing. (“Fine” and “coarse” here are relative roles, not fixed diameters: a 0.4/0.8 pairing works by the same logic as a 0.2/0.6 pairing, with 0.4 playing the fine role in the first case. The rest of this document uses 0.2mm fine / 0.6–0.8mm coarse as a concrete illustration, since it’s the widest and most demanding spread available across Bambu’s own nozzle lineup, but the mechanism is diameter-agnostic and hardware-agnostic.) Anywhere a region is provably identical at the fine nozzle’s resolution to what the coarse nozzle’s bead would produce, substitute the coarser nozzle there for speed. Everywhere that substitution isn’t provably safe, stay fine. The coarse nozzle is strictly a speed optimization over a description that never changes — there’s no reconciliation between two different things, because the coarse region is a faithful shortcut for the fine region, not a different thing meeting it.
Fine Skin: the user-facing surface
Whatever the underlying mechanism, it doesn’t need to be user-configured directly. Model the front end the way Bambu Studio already models Fuzzy Skin: a named treatment (“Fine Skin”), applicable globally by rule (all outer walls, all features under N mm) or painted onto specific regions, with paint always available as an override. The user expresses intent — spend additional fidelity here — and the slicer/firmware decides how to deliver it given the hardware. Everything below this line is what happens underneath that request; none of it needs its own UI.
Layer groups and the flush-only-at-boundary rule
Define a layer group: a Z-band reachable both by N sublayers at the pairing’s fine diameter and by exactly one layer at the pairing’s coarse diameter, with the group height solved per-region as a mutually-reachable value (layer height is already continuously variable via squish/flow-rate, not fixed to nozzle diameter).
The rule: fine and coarse may only meet at the top of a group, never mid-band.
This is an access constraint, not a travel constraint, which is the important distinction — it’s not solvable with a Z-hop before a travel move, the way ordinary stringing-avoidance is. A nozzle is a cone that widens with height, so depositing material immediately adjacent to an already-printed tall wall means the cone’s flank has to occupy space the wall already fills, right at the point of deposition. If coarse prints first, there’s a wedge of geometrically unreachable space at the base of every tall coarse feature — no travel maneuver reaches it, because the obstruction is at the destination, not in the flight path. Fine must print first within a group for this reason: it’s placing material on a clean flat surface with nothing tall nearby yet, so there’s no access problem at all. Coarse then fills the remainder, inset from the fine feature by its own clearance radius, which the fine geometry already accommodates.
This rule caps a group at two nozzle sizes — a third size introduced mid-band would need to meet the fine stack at a non-boundary Z, reopening the access problem. Adjacent groups (different Z, or different XY regions at the same Z) are unconstrained and can each independently use a different coarse partner, so the full 0.2–0.8mm range remains available across a job — just never more than two sizes within one group.
Where coarse is allowed to substitute
Two tests per candidate region, both fail-safe toward fine:
Stability: are the region’s contours congruent across all N fine sublayers in the group? A region that steps in and out mid-group fails automatically and stays fine.
Clearance: once inset by the coarse bead’s radius, is the remaining region wide enough for the coarse nozzle to deposit?
Because coarse only wins where both tests pass, visible or complex geometry is guaranteed to stay at fine resolution — the optimization can only trade fill-speed for fill-speed in verified-simple bulk, never surface quality for speed.
Why a shared layer height isn’t a viable long-term target
This is likely the single most important point in this document, and it’s a hard physical constraint, not a design preference.
Printable layer height for FDM nozzles runs roughly 20–80% of nozzle diameter. That gives a printable range per nozzle:
Nozzle
Range
0.2mm
0.04–0.16mm
0.4mm
0.08–0.32mm
0.6mm
0.12–0.48mm
0.8mm
0.16–0.64mm
The pairings below use 0.2mm as the fine reference since it’s the most demanding case, but the same intersection logic applies to any pairing from the table — a 0.4/0.8 pairing, for instance, intersects at 0.16–0.32mm, a real and workable range for that pair, by the identical math.
A shared-layer-height model — one global Z-step across all nozzles in a job — is constrained to the intersection of whichever ranges are in play, not either nozzle’s own range:
0.2 + 0.4: intersection 0.08–0.16mm. Real overlap; most of the fine nozzle’s practical range survives, and this pairing works reasonably well shared.
0.2 + 0.6: intersection narrows to 0.12–0.16mm. Most of the fine nozzle’s useful range is gone.
0.2 + 0.8: intersection is a single point, 0.16mm — not a usable range at all. Under shared layer height, this pairing is functionally unprintable together.
That last row matters for any hardware capable of mounting a 0.2mm and 0.8mm nozzle in the same job — H2D and X2D’s independent dual nozzles included, not just Vortek’s rack. It’s worth flagging for Vortek specifically as well, since 0.2–0.8mm is the full advertised range of the induction hotend lineup: a mixed-nozzle feature that only works cleanly for adjacent diameter pairs doesn’t deliver on the actual spread that lineup offers, on whichever platform it’s mounted.
There’s a second cost even where the intersection is nonempty: squishing a coarse nozzle toward the bottom of its range to stay compatible with a fine nozzle doesn’t just risk the flow-inconsistency issues that show up near the low end of any nozzle’s range — it also caps volumetric throughput (cross-section ≈ line width × layer height), which is the actual lever multi-nozzle hardware exists to pull. A 0.6mm nozzle squished to 0.16mm layers is running at roughly a third of its own natural throughput ceiling — present and technically printable, but not delivering the speed the larger nozzle was chosen for. Full utilization of a coarse nozzle’s speed advantage requires both a wide bead and a layer height sized to that nozzle’s own natural range — which per-group Z-reconciliation provides and a single shared Z-step cannot.
Put simply: if time-of-print doesn’t matter, a single 0.2mm nozzle everywhere already gives maximum resolution — that’s the null hypothesis multi-nozzle hardware exists to beat. A mixed-nozzle implementation that can’t let the coarse nozzle run near its own natural layer height isn’t actually delivering the reason someone would want multi-nozzle hardware in the first place; it’s delivering a modest quality/strength benefit at close to single-nozzle print time.
Where color enters: Vortek slot budget
Vortek gives fast, no-flush color/material swaps because each hotend stays pinned to one filament identity for the job. If a color is allowed to split across fine and coarse diameters, its true identity becomes (color, diameter), needing two dedicated slots rather than one.
On H2C specifically: 6 automatic Vortek identities (1 mounted + 5 racked, per Bambu’s own published spec) plus 1 fixed manual hotend on the left — 7 total, not independent from the diameter-splitting decision. Every color that gets diameter-split draws down the same finite pool that color-swap speed depends on; pushed too far, it reintroduces the flushing Vortek exists to eliminate.
Where color and diameter decouple entirely: if every visible surface color is opaque enough to fully hide whatever’s beneath it, structure color doesn’t need to match surface color at all — one shared, fast, universal structural color can serve every visible color in the job, diameter-split freely, at a cost of one slot total regardless of color count.
Where they don’t: a translucent or light surface color needs its coarse fill to color-match to avoid show-through, which costs a full second slot per such color. This is the one place in the whole model that isn’t geometric — it requires an empirical fact (minimum hide-shell thickness per material/color pair) that nothing in current slicer or firmware logic models.
Suggested default, given that: rather than modeling opacity, a fixed, safe allocation — 3 colors × 2 diameters = 6 identities, matching the 6-slot automatic Vortek pool, every color always getting its own dedicated coarse variant — is correct regardless of material opacity, at the cost of leaving opaque-job shared-structure savings on the table. The 7th, fixed-left identity sits naturally outside that allocation as a place for a single always-available color that doesn’t diameter-split. An advanced/override mode, letting a user manually declare which colors are safe to share structure, can recover the opaque-job savings for anyone willing to make that call — same rule-plus-override pattern as Fine Skin itself.
Relationship to existing slicer-side work
OrcaSlicer has an in-progress community PR (LixNix, #13782) extending per-feature nozzle/filament assignment (walls vs. infill vs. top-bottom) to Bambu’s multi-nozzle machines, and there’s an open community discussion (#10175) from an IDEX printer owner independently identifying shared layer height as “the most significant drawback” of multi-nozzle printing in practice — corroboration that this gap is real-world, not theoretical. That work is valuable and solves a real, adjacent problem (particularly for close-diameter pairs and material-property differentiation, e.g. rigid vs. foamed material in one part) — it’s a different, narrower mechanism than the one above, not a competing solution to the same problem, and nothing about implementing the band model above would conflict with it.
Why this matters commercially, not just technically
0.4mm was never an optimum — it was a forced compromise, and it’s worth being precise about why. 0.2mm is too slow and incompatible with a range of filled/abrasive filaments. 0.6mm and 0.8mm show visible layer lines and lose small features often enough to be disqualifying for anything cosmetic or customer-facing. 0.4mm isn’t the best point on a curve — it’s the only single value that avoids both failure modes at once, because a print could only ever have one nozzle. The moment that constraint is gone, there’s no reason for one value to survive both failure modes simultaneously: visible surfaces get the resolution that avoids “looks bad,” hidden bulk gets the diameter that avoids “too slow.” The entire installed base of 0.4mm-default usage is evidence of a workaround for a hardware limitation, not evidence of a preference for 0.4mm itself.
The strongest market case isn’t speedup on existing jobs — it’s jobs currently declined outright. A straightforward 2-4x speed argument on already-quoted work is a real, useful case (more competitive bids, better margins on multi-color/fine-detail jobs a farm already serves), but it’s competing for revenue that already exists in the market. The larger opportunity is upstream of that: requests a print farm currently can’t accept at any reasonable price, so they’re never quoted at all. The clearest example is also the technical ceiling case for this whole model — a part needing genuinely fine (down to ~0.04mm) surface finish on visible geometry, with real structural bulk underneath. Today that request gets declined for FDM and routed to resin (different process, different size and material constraints, different cost structure) or accepted at an honest, embarrassing quote reflecting printing the entire part at 0.04mm. Under a shared-layer-height model this pairing isn’t just slow, it’s mathematically unprintable together — the 0.2mm and 0.8mm printable ranges (0.04–0.16mm and 0.16–0.64mm respectively) share only a single boundary point, not a usable range. Per-tool layer height is the only architecture that can accept this class of job at all, not just accept it faster. That’s a claim about expanding what a print farm can say yes to, not about doing the existing catalog more efficiently — a materially different, and generally more persuasive, kind of business case.
Automotive replacement parts are a concrete, present-day example of this exact shape of demand. A functional under-hood bracket in CF-nylon where nobody will ever see it is already well served by a single coarse nozzle today — that’s not a new opportunity. The interesting case is a visible replacement part (trim, housing, anything replacing a smooth OEM surface) that also needs real structural integrity and, often, functional mating-surface tolerance — a connector shroud, a gasket seat, a bearing bore — where visible layer lines aren’t just unsightly, they can mean a leak path or a fit problem. That’s a job with genuine hidden bulk and a non-cosmetic reason to demand fine resolution on the skin, and stair-stepping on the curved surfaces common to this category is precisely where fine resolution has the most visible leverage. This is a job type that exists today, gets either quoted high or declined, and would move cleanly into “yes” territory under this model.
Every mechanism here — bands, flush-boundary ordering, stability/clearance tests, swap scheduling, color/diameter slot allocation — is either a bounded extension of something slicers already do elsewhere, or a direct consequence of nozzle physics (squish range, cone geometry, volumetric flow) that doesn’t require new material science to account for. The one genuinely new input — opacity-driven structure sharing — is deliberately kept out of automated inference and left to a safe default plus an explicit user choice. Given that Bambu already controls swap and Z-motion timing at the firmware level across its multi-nozzle hardware, this is buildable correctly in a way no third-party slicer can currently match from outside that hardware.
A very nice AI generated story!
Nevertheless, most of the things mentioned here are true, but some are not really relevant to the story.
It clearly describes the requirements for path ordering based on adjacent paths of different heights, but it partially discards the conflicts it creates with other ordering rules. It proposes for those cases to always fall back to the fine (smallest nozzle) solution. However, what all the mentioned rules applied, mean to a real time part are still unknown.
The OrcaSlicer developments that are mentioned, are currently merely scratching the surface of multi-size nozzle printing, but we have to start somewhere.
Maybe you should ask the same AI to program the solution it had in mind here, and create a Commit for OrcaSlicer so we can test it. 
It’s like reading an aimless stream of consciousness core dump. Is it some kind of flooding weapon for jamming discourse?
It requires lots of focus and time to plough through the story.
But I wanted to comprehend the content before making serious remarks.
He might have asked the AI to come up with a more compressed overview.
It might be, as he is posting another large topic also.
Though I think his intentions are sincere.
Since you’ve done the work of ploughing through it, what was the point he was making? I had a stack overflow long before I could figure out what his conclusion was.
My goal was to devise a strategy that would:
Do I need this personally? No, not in what I am currently working on. However, I do use a .2mm nozzle quite often, and I do need the quality that it offers.
Background:
Printers that I have: Bambu P1P and more recently a BambuH2C.
My work that requires.2mm nozzles: I have developed an SMT (electronics Surface Mount Technolog, using 3d printing for assembly jigs) system for populating printed circuit boards. If you do your own SMT boards, you likely use a stencil to spread the solder paste. For smaller surface mount components, the “sweet-spot” for stencils (for spreading the paste) is a mere .12mm thickness. As you go up in thickness, you end up with more paste deposited for each aperture in the stencil, so when you reflow, you have too much paste and this may cause bridging (shorts) and the board fails.
So, … yes, I have a LOT of experience with high-resolution FDM printing, through many hours of experimentation and iteration, in pushing quality envelopes.
But that said, printing these stencils will not benefit from a .2mm and a .6mm nozzle, where the .2mm is for the “fine” surfaces, and the .6mm nozzle is for the speed. Why? Because the stencil portion is only .12mm thick. After much experimentation I can print a stencil that doesn’t tear apart when used. This saves me ordering (and waiting for) a stainless steel for my boards.
I have looked at the times necessary for printing things like planter pots at a higher quality, and am aware that dropping from a .4mm to a .2mm nozzle will often increase the print time from 4x or 5x, or possibly even worse. I am aware of the value proposition, even if I will not benefit.
So, my HUMAN idea (which I used AI to help me author, but that’s all … the research and analysis was days of my volunteer time) was basically this:
a. printing the entire part with a .2mm nozzle gets you the quality you want. an existence proof if you will … the part can be printed.
b. the “only” thing wrong with that is the time it takes.
c. therefore replace all non-surface aspects that you can in your print with a bigger nozzle for speed.
I think of it like building a wall in a house. (Yes, I also remodel houses.) First the studs, then drywall, then tape/mud, then paint. At that point you don’t care what the inside of the wall looks like.
Since we can already print high quality, it is only about saving print time. If the .2mm nozzle was fast enough, there wouldn’t even be these threads discussing the need for mixed nozzles in a single print.
So, mathematically …
Looking at existing approaches that try to align the layer height between the two layers doesn’t get maximum throughput for the larger nozzle. Its layer height has to be restricted to what the smaller nozzle can have as a MAXIMUM layer height. This is why a shared layer height approach mathematically can’t near the max speed.
This last point needs to be examined, because it is a very general assertion. If you use lightning infill, there is so little opportunity to NOT print surface (quality), that nothing will gain you much time. If you are for example printing planter pots that don’t have to hold dirt, then they are basically just a shell. If you want .2mm quality here, no scheme is going to help you much.
So, back to the shared layer height: This will be a limitation on both speed (you have to slow down the larger nozzle extrusion to generate a thinner layer), AND what is possible in terms of layer heights. To solve this, you need a solution that doesn’t have this restriction.
So okay, cool. What can be done there? At some specific height, if you extrude with the large nozzle first, and then the fine nozzle, you have to LOWER the head (raise the bed) to be able to do that. This will potentially cause collision with the thicker extrusions as the fine nozzle moves around.
So okay, proceeding with this logic: Do the fine nozzle first. Hence the title “fine-first”. That’s the base insight. Nothing profound. Nothing AI generated. (Oh, and BTW, one of the other things I am working on is AI Governance and Epistemology runtimes, as well as writing about AI. So yes, I am very familiar with what AI can and can’t do.)
So what does fine-first buy you? You can use say 3 layers at fine to build up to what will be done in a single extrusion with the larger nozzle. These fine layers that you are building up won’t cause collisions, because this is just basic 3d printing. When you do get around to printing with the larger nozzle, your built-up fine layers are already at the height that the larger nozzle will be printing at, so again, no collisions.
How does this not work as a strategy for all parts? What am I missing?
Oh, and from what I am working on, … I learned first hand about the “heat creep” problem that H2C’s encounter when using .2mm nozzles, or slower printing, or ironing, etc. My stencil prints have a harder time working on my H2C than they do on my P1P. I therefore analyzed the failures and made a recommendation for fixing that.
Now, some advice: Is this the kind of response I should expect here after putting a lot of personal time and thought and effort into my posts? I just joined this forum, having worked hard to come up with possible solutions for what I thought were hard problems. I am not inclined to continue if this is the “reward”.
The takeaways to my opinion is that we are having some experimental implementations in Orcaslicer and Prusaslicer.
There is no layer height separation which causes restrictions on the height versus nozzle diameter.
A lot of explanations about layer ordering when separating heights would be implemented.
It misses a lot of the detailed flaws of the current implementations, but it understands the additional problems that occur when you combine different widths.
A mention that the 0.4mm nozzle is not the best diameter, but more a compromise between speed and detail. This is already known for a very long time though.
A lot of talk about pro’s and con’s of different sizes.
It’s very detailed, which is interesting for deep dive, but a more compressed version (probably 1/3) should be enough for most to understand what it’s about.
I dropped the text in AI to make an executive summary. See the result below 
Mixed‑diameter printing is already planned for Bambu Lab hardware; this document proposes a firmware‑level method that makes it physically correct, reliable, and commercially valuable.
The core idea is simple: Use the fine nozzle to define all geometry, and let the coarse nozzle accelerate only where it can safely reproduce that geometry.
To achieve this, the print is divided into fine‑first Z‑bands (“layer groups”). Within each band:
This architecture avoids the fundamental flaw of shared layer height, which restricts mixed‑nozzle pairs to the narrow intersection of their printable ranges. Wide pairings like 0.2 mm + 0.8 mm become mathematically impossible under shared layer height but work cleanly under the band model, allowing each nozzle to operate at its natural layer height and throughput.
Color handling is solved through Vortek’s purge‑free hotend identities. Colors may be split into fine/coarse variants when needed, with a safe default allocation matching Vortek’s slot budget and optional user overrides for opaque materials.
The model is compatible with ongoing OrcaSlicer work (e.g., per‑feature nozzle assignment) but solves a different problem: true mixed‑diameter printing without sacrificing geometry, speed, or hardware capability.
Commercially, the biggest impact is not incremental speedups but enabling entire classes of currently impossible jobs—parts requiring very fine visible surfaces and strong structural bulk. This expands what print farms can accept, not just how fast they print.
In short: This approach unlocks the full promise of multi‑nozzle hardware—fine where it matters, fast where it’s safe—without the geometric and throughput limitations of shared layer height.
AI probably could do it.
This is my air quality monitor, fully integrated into home assistant and fully coded by AI and most of the documentation has been created by AI (probably a good thing cos my spelling is rubbish lol)
It works amazing, even uses a 24ghz radar to detect if someone is in the room and wakes the display and has alarms and can be snoozed.
Will be released very shortly as open source for all the 3D printing community to use if they want.
