inner-outer-inner/infill wrong order?

[zviratko]

Either I don't get the purpose of the inner-outer-inner/infill or it is not working right

With 3 walls and infill the order looks like this:

1. outermost wall
2. innermost wall
3. middle wall
4. infill

I thought it was supposed to work like this (for 3 walls):

1. middle wall
2. outer wall
3. inner wall(s)
4. infill

This would preserve dimensions because infill or multiple walls aren't pushing anything out if inexact while making overhangs work better (by the outer wall also sticking to the middle wall).
I am trying to think of a reason this should work differently and I also believe if that's the case then it is named wrong, as it clearly should either be laying inner wall first or be named "outer-inner-middle-infill" or something like that. I wasn't able to find a description for what exactly this is supposed to do, though...

[SoftFever]

The order of sandwich mode for 3-wall should be:
Inner
Outer
Middle

[zviratko]

This is not the case, I am attaching a 3mf with a simple cube that shows the problem.
infillbug.zip

[SoftFever]

Are you using the 1.5 dev build?
There is a regression bug in the dev branch.

You should be able to see the correct behavior in 1.4.5

[zviratko]

Ah, sorry. Yeah, I am running some recent action build (1.5.0 merge I think).

Is there a way to achieve the ordering I thought it was supposed to be?
middle wall
outer wall
inner wall(s)
infill

Or should I open a RFE for that or something?
Thanks

[SoftFever]

I failed to see any benefits to printing in middle-outer order, can you elaborate the use case?
It is basically a worse version of inner-outer order IMHO.

[zviratko]

Well, the reason why outer->inner is better for mechanical parts is accuracy. Overextrusion or inaccuracy in inner walls or infill won't affect the outer wall if it's laid down first.
The reason why most people don't actually use it is because it's much worse for overhangs, as the material is only holding partly on the previous layer making it free to ooze down. Having a wall next to it first makes it much easier to stick to it as well (surface tension?)

My proposal with middle (2nd outermost)->outer->inner/infill would be a compromise - you are still affected by inaccuracy in 1 wall but not by multiple inner walls

(btw I actually fail to see any benefit to using the sandwich mode as it's supposed to work, is that described somewhere?)

[SoftFever]

It is described in previous release notes.Sent from my iPhoneOn 14 Mar 2023, at 1:30 AM, Jan Schermer ***@***.***> wrote: Well, the reason why outer->inner is better for mechanical parts is accuracy. Overextrusion or inaccuracy in inner walls or infill won't affect the outer wall if it's laid down first. The reason why most people don't actually use it is because it's much worse for overhangs, as the material is only holding partly on the previous layer making it free to ooze down. Having a wall next to it first makes it much easier to stick to it as well (surface tension?) My proposal with middle (2nd outermost)->outer->inner/infill would be a compromise - you are still affected by inaccuracy in 1 wall but not by multiple inner walls (btw I actually fail to see any benefit to using the sandwich mode as it's supposed to work, is that described somewhere?) —Reply to this email directly, view it on GitHub, or unsubscribe.You are receiving this because you commented.Message ID: ***@***.***>

[Wulfsta]

@SoftFever I would also be interested in the proposed perimeter mode, as a compromise between minimizing the impact of inner layers on the outer surface (less error introduced to the outer perimeter from a single interior perimeter than the cumulative error from several), maximizing the probability of a successful steep overhang, and reducing the impact of travel moves on the outer surface (as I believe was the original intent of sandwich mode). Would be happy to open a feature request or discuss offline if this thread is not appropriate.

[skuep]

Found this by accident since I was about to open a feature request.

I would really love the wall order proposed above:

1. 2nd to outside wall
2. Outside wall
3. Rest of wall and infill

I use outer perimeter first, because it gives very good print quality (this is actually a tip from Ellis print tuning guide). But overhangs are always somewhat troublesome. This could be solved with this feature as a good compromise.

Is there any incentive/resources available for implementing something like this?

[zviratko]

I still consider the current behaviour to be bad and simply changing it to what I proposed will be beneficial. With large number of walls, the outer shell gets inexact and muddled while also having poor overhangs, so I have no idea what it's even supposed to achieve.

[skuep]

Yeah, it's weird. It left me sleepless nights, after discovering it and then noticing what it actually does...
Does anyone with knowledge of the codebase know where/who the root of this feature is?

[Wulfsta]

It’s nontrivial, I looked into it in the past but didn’t have time to wrap my head around it to make the change. See here and here.

[skuep]

I see.. thanks for finding the location. from the looks of it, the code already does separate/index the separate perimeter lines. Maybe it's just a matter of changing the order of them in the slicing "result".

I am a bit more scared of the tools and libraries required to build the thing. I have to look up if there is some guidance for building (on Linux in this case).

Edit: it's right there in the readme 😁

[zviratko]

I am a bit more scared of the tools and libraries required to build the thing. I have to look up if there is some guidance for building (on Linux in this case).

Edit: it's right there in the readme 😁

If you do a pull request it should build it for you, I think (not a dev :))
I would be very happy to test it.

[Wulfsta]

@skuep happy to help if you attempt it and get blocked - I'm not familiar with this code, but might be able to lend a hand if anything comes up.

[SoftFever]

@SoftFever I would also be interested in the proposed perimeter mode, as a compromise between minimizing the impact of inner layers on the outer surface (less error introduced to the outer perimeter from a single interior perimeter than the cumulative error from several), maximizing the probability of a successful steep overhang, and reducing the impact of travel moves on the outer surface (as I believe was the original intent of sandwich mode). Would be happy to open a feature request or discuss offline if this thread is not appropriate.

So, your assumption is that the push force can be accumulated and passed to the outer wall all the way from the innermost wall?
I have doubts but still an interesting idea.
I will see if I can make an PR build for you all to test by end of this week.

[Wulfsta]

So, your assumption is that the push force can be accumulated and passed to the outer wall all the way from the innermost wall? I have doubts but still an interesting idea.

My thought is more so that an error introduced that yields additional plastic (some bulge in the perimeter) would be additive due to the deposited plastic being in the path of the next perimeter. The error wouldn’t quite be additive, but more like applying ReLU before a sum. I am interested in testing it out though, so thanks for looking into implementing.

[skuep]

Exactly.. see here for examples:
https://ellis3dp.com/Print-Tuning-Guide/articles/troubleshooting/extrusion_patterns.html#external-perimeters-first
And
https://ellis3dp.com/Print-Tuning-Guide/articles/troubleshooting/bulging.html

Thanks a lot for your work! 🙂

[SoftFever]

My thought is more so that an error introduced that yields additional plastic (some bulge in the perimeter) would be additive due to the deposited plastic being in the path of the next perimeter. The error wouldn’t quite be additive, but more like applying ReLU before a sum. I am interested in testing it out though, so thanks for looking into implementing.

I mean, that's exactly why the outer-inner order exists in all slicers, and it's the precise reason why Orca introduced the inner-outer-inner order in the first place. You need to lay down the outer wall before the second outermost wall to avoid such errors.

[SoftFever]

Exactly.. see here for examples: https://ellis3dp.com/Print-Tuning-Guide/articles/troubleshooting/extrusion_patterns.html#external-perimeters-first And https://ellis3dp.com/Print-Tuning-Guide/articles/troubleshooting/bulging.html

That's just the normal 'outer wall first' mode. I have a strong feeling that you might have misunderstood why 'outer wall first' works and why Orca introduced the 'sandwich mode' to improve upon that

[zviratko]

But the sandwich mode results in both poor overhangs and poor dimensional accuracy, as you are pushing more plastic around an already inexact (bulging) perimeter, which will ever so slightly affect the outer perimeter, even if it has somewhat cooled down, also what does it do to the next layer when there's a bulge on the top near the edge? If you lay down the second outermost perimeter first, then the outer perimeter, then the 3rd and up (going inward), then you get almost perfect accuracy but maintain good overhang angles and whatever excess material there is ends up pushing against infill doing no harm.

Just try it for yourself.
For a concete example, try printing this https://www.printables.com/model/928-yet-another-fidget-infinity-cube-v2
This model feels best when heavy, 80% infill works but using more walls would be better because then you also get more strength (not that it matters in this example). But with large number of perimeters (say 10?) and either inner-outer or sandwich mode, it usually gets fused. It works the same way on anything the requires precision (herringbone gears fidget from emmet does the same thing for example and also needs some overhangs if you don't print it with PLA).

[skuep]

That's just the normal 'outer wall first' mode. I have a strong feeling that you might have misunderstood why 'outer wall first' works and why Orca introduced the 'sandwich mode' to improve upon that

Yes, it's the outer wall first mode. I understand very well how this works. However it has the downside of overhangs being quite troublesome. Thus, an "improvement" in my book would be to use the advantage of 'outer wall first' (at least to some degree) but still be able to print overhangs. Yes, this 'second-outer wall first' can still produce defects on the outer wall, but to a much lesser degree than the regular wall order, where a lot more internal walls are printed, before the outer wall is printed.

why Orca introduced the 'sandwich mode' to improve upon that

I think we are all wondering here, what exactly the improvement of the 'sandwich mode' is over 'outer wall first'? In fact, that is the whole reason this issue exists :-)

[SoftFever]

But the sandwich mode results in both poor overhangs and poor dimensional accuracy

I have conducted extensive testing by myself, and have also received feedback from a wide range of users, both through public forums and private messages. e.g.
https://www.reddit.com/r/BambuLab/comments/130epbk/comment/jhwdnna/
#18 (comment)

, as you are pushing more plastic around an already inexact (bulging) perimeter, which will ever so slightly affect the outer perimeter, even if it has somewhat cooled down, also what does it do to the next layer when there's a bulge on the top near the edge? If you lay down the second outermost perimeter first, then the outer perimeter, then the 3rd and up (going inward), then you get almost perfect accuracy but maintain good overhang angles and whatever excess material there is ends up pushing against infill doing no harm.

How? In sandwich mode, when you lay down the outer wall, its neighboring inner wall has not been laid yet, so there is no effect from the inner wall on the outer wall. As the following screenshot demonstrates.

If you lay down the second outermost perimeter first, then the outer perimeter, then the 3rd and up (going inward), then you get almost perfect accuracy

Again, this is not correct. "Lay down the second outermost perimeter first, then the outer perimeter" is exactly the reason why surface quality suffers.

Just try it for yourself. For a concete example, try printing this https://www.printables.com/model/928-yet-another-fidget-infinity-cube-v2 This model feels best when heavy, 80% infill works but using more walls would be better because then you also get more strength (not that it matters in this example). But with large number of perimeters (say 10?) and either inner-outer or sandwich mode, it usually gets fused. It works the same way on anything the requires precision (herringbone gears fidget from emmet does the same thing for example and also needs some overhangs if you don't print it with PLA).

"It usually gets fused' has nothing to do with dimensional accuracy. For such print-in-place models, you just need to adjust the travel distance threshold to enforce retraction, even for very short travels.

[SoftFever]

That's just the normal 'outer wall first' mode. I have a strong feeling that you might have misunderstood why 'outer wall first' works and why Orca introduced the 'sandwich mode' to improve upon that

Yes, it's the outer wall first mode. I understand very well how this works. However it has the downside of overhangs being quite troublesome. Thus, an "improvement" in my book would be to use the advantage of 'outer wall first' (at least to some degree) but still be able to print overhangs. Yes, this 'second-outer wall first' can still produce defects on the outer wall, but to a much lesser degree than the regular wall order, where a lot more internal walls are printed, before the outer wall is printed.

Sandwich is not trying to solve the overhang issue for outer wall first.
It's like outer wall first, is meant for models that has small overhang angles.
For model with large overhang angle, you can try the Precise-wall instead

why Orca introduced the 'sandwich mode' to improve upon that

I think we are all wondering here, what exactly the improvement of the 'sandwich mode' is over 'outer wall first'? In fact, that is the whole reason this issue exists :-)

I think I need find sometime to write a WIKI for this :)
Meanwhile here is a very short description of it:
quoted from this release note

Add a new printer order - sandwich mode:
This new order is similar to the outer-wall-first mode in achieving the best dimensional accuracy. This new approach however avoids printing outer walls right after a long travel, which may cause artifacts on the surface in many cases.

[Wulfsta]

I have to agree with @SoftFever here, my interest in this lies in the idea that error can be accumulated additively over several perimeters, and this approach would try to minimize that effect while maximizing the probability of a successful overhang, as well as removing error introduced from travel moves like sandwich mode does (as I originally mentioned). This would only be useful on models with high overhang and four or more perimeters (which happens to be a lot of things I print). On a four perimeter model the order would be inner -> second-most outer -> outer -> third-most outer.

[skuep]

To be honest, I don't have any issue whatsoever with outer walls after "long travel moves" (which is what the sandwich mode is supposed to solve) but that is besides the point, since apparently some people are.

On a four perimeter model the order would be inner -> second-most outer -> outer -> third-most outer.

I could live with that! Isn't that the ultimate compromise? Reiterating:

1. inner first -> Avoid issues with the long travel moves producing visible artifacts
2. second-most outer -> Better overhang performance
3. outer -> Still nice performance (given the circumstances)
4. fill in all missing perimeters

@SoftFever: Would this be a nice addition to the sandwich mode? I think it won't (negatively) effect the current users but still benefit others. And the change to the current sandwich mode is merely to prioritize the second-most outer wall above the outer wall (if I am not mistaken).

[Wulfsta]

@SoftFever: Would this be a nice addition to the sandwich mode? I think it won't (negatively) effect the current users but still benefit others.

This should be a new perimeter mode altogether if it gets implemented, sandwich mode already works and has been extensively tested to show the benefit. No reason to make a breaking change to a working feature.

[skuep]

That's also fine..
In that case I think it would be best to have the order as written originally.

1. Second most outer perimeter
2. Outer perimeter
3. Remaining perimeters

And call this something like "outer wall first plus". The reasoning behind this is, that this accomplishes what it's supposed to do down to 3 perimeters. Whereas @Wulfsta s order would print inner, middle outer, which is suboptimal in terms of print quality. Better would be 2nd-outer, outer, inner.

I would love to test this out and compare it against outer wall first. I will try to look into it on the weekend and see how much effort this is.

[zviratko]

"It usually gets fused' has nothing to do with dimensional accuracy. For such print-in-place models, you just need to adjust the travel distance threshold to enforce retraction, even for very short travels.

I can get 0.05mm knob to turn on Maker's Muse accuracy spinner and I get completely freely spinning gears on gear bearing spinners once removed from build plate, and that is with the standard Inner/Outer wall order but with 2 walls only. Once I use more, then it starts getting fused because everything gets pushed outward. And I have yet to see any sort of "gap fill" or single line fill in between existing walls to not have a visible bulge upwards indicating there's more material than needed, this is going to accumulate as well. And no, it's not an issue with flow rate, if I were to tune it to not do that I'd end up with extremely weak prints. I don't have a scientific explanation for that happening, just a vague idea, but I don't think it matters.
Let's agree to disagree on that, hopefully someone implements this and we get to test it for ourselves, I'm pretty confident the outcome will be net positive :)

[skuep]

I've had a go at it by trying to just modify the existing inner-outer-inner mode as a first step. See my branch here:
https://github.com/SoftFever/OrcaSlicer/compare/main...skuep:OrcaSlicer:inner-outer-inner-reverse?expand=1

There are two #if sections, the first one works (but doesn't really change the wall order at all), but as soon as I flip the first loop, OrcaSlicer crashes with all kinds of memory access errors (segmentation fault, invalid pointer, etc). The debug output however looks fine to me.

I slice the Micron Calibration Cube (but it shouldn't matter). If you want to try, you need to use Arachne and set the wall order in the GUI to inner-outer-inner.

Does anyone have a clue why this happens? Otherwise these debug lines look fine to me

Works:

New Layer: Layer ID 75
Layer ID 75, Outer index 0, inner index 1, second inner index 2, maximum internal perimeter 3 
Inside out loop: Mapped perimeter index 0 to array position 0
Inside out loop: Mapped perimeter index 1 to array position 1
Outside in loop: Mapped perimeter index 2 to array position 2
Outside in loop: Mapped perimeter index 3 to array position 3
Layer ID 75, Outer index 4, inner index 5, second inner index 6, maximum internal perimeter 7 
Inside out loop: Mapped perimeter index 4 to array position 0
Inside out loop: Mapped perimeter index 5 to array position 1
Outside in loop: Mapped perimeter index 6 to array position 2
Outside in loop: Mapped perimeter index 7 to array position 3
Layer ID 75, Outer index 8, inner index 9, second inner index 10, maximum internal perimeter 11 
Inside out loop: Mapped perimeter index 8 to array position 0
Inside out loop: Mapped perimeter index 9 to array position 1
Outside in loop: Mapped perimeter index 10 to array position 2
Outside in loop: Mapped perimeter index 11 to array position 3
New Layer: Layer ID 0
New Layer: Layer ID 4
Layer ID 4, Outer index 0, inner index 1, second inner index 2, maximum internal perimeter 3 
Inside out loop: Mapped perimeter index 0 to array position 0
Inside out loop: Mapped perimeter index 1 to array position 1
New Layer: Layer ID 131
Layer ID 131, Outer index 0, inner index 1, second inner index 2, maximum internal perimeter 3 
Inside out loop: Mapped perimeter index 0 to array position 0
Inside out loop: Mapped perimeter index 1 to array position 1
Outside in loop: Mapped perimeter index 2 to array position 2
Outside in loop: Mapped perimeter index 3 to array position 3
Layer ID 131, Outer index 4, inner index 5, second inner index 6, maximum internal perimeter 7 
Inside out loop: Mapped perimeter index 4 to array position 0
Inside out loop: Mapped perimeter index 5 to array position 1
Outside in loop: Mapped perimeter index 6 to array position 2
Outside in loop: Mapped perimeter index 7 to array position 3
....
New Layer: Layer ID 129
Layer ID 129, Outer index 0, inner index 1, second inner index 2, maximum internal perimeter 3 
Inside out loop: Mapped perimeter index 0 to array position 0
Inside out loop: Mapped perimeter index 1 to array position 1
Outside in loop: Mapped perimeter index 2 to array position 2
Outside in loop: Mapped perimeter index 3 to array position 3
Layer ID 129, Outer index 4, inner index 5, second inner index 6, maximum internal perimeter 7 
Inside out loop: Mapped perimeter index 4 to array position 0
Inside out loop: Mapped perimeter index 5 to array position 1
Outside in loop: Mapped perimeter index 6 to array position 2
Outside in loop: Mapped perimeter index 7 to array position 3
New Layer: Layer ID 111
Layer ID 111, Outer index 0, inner index 1, second inner index 2, maximum internal perimeter 3 
Inside out loop: Mapped perimeter index 0 to array position 0
Inside out loop: Mapped perimeter index 1 to array position 1
Outside in loop: Mapped perimeter index 2 to array position 2
Outside in loop: Mapped perimeter index 3 to array position 3
Layer ID 111, Outer index 4, inner index 5, second inner index 6, maximum internal perimeter 7 
Inside out loop: Mapped perimeter index 4 to array position 0
Inside out loop: Mapped perimeter index 5 to array position 1
Outside in loop: Mapped perimeter index 6 to array position 2
Outside in loop: Mapped perimeter index 7 to array position 3

Crash:

New Layer: Layer ID 75
Layer ID 75, Outer index 0, inner index 1, second inner index 2, maximum internal perimeter 3 
Inside out loop: Mapped perimeter index 1 to array position 0
Inside out loop: Mapped perimeter index 0 to array position 1
Outside in loop: Mapped perimeter index 2 to array position 2
Outside in loop: Mapped perimeter index 3 to array position 3
Layer ID 75, Outer index 4, inner index 5, second inner index 6, maximum internal perimeter 7 
Inside out loop: Mapped perimeter index 5 to array position 0
Inside out loop: Mapped perimeter index 4 to array position 1
Outside in loop: Mapped perimeter index 6 to array position 2
Outside in loop: Mapped perimeter index 7 to array position 3
Layer ID 75, Outer index 8, inner index 9, second inner index 10, maximum internal perimeter 11 
Inside out loop: Mapped perimeter index 9 to array position 0
Inside out loop: Mapped perimeter index 8 to array position 1
Outside in loop: Mapped perimeter index 10 to array position 2
Outside in loop: Mapped perimeter index 11 to array position 3
New Layer: Layer ID 56
Layer ID 56, Outer index 0, inner index 1, second inner index 2, maximum internal perimeter 3 
Inside out loop: Mapped perimeter index 1 to array position 0
Inside out loop: Mapped perimeter index 0 to array position 1
Outside in loop: Mapped perimeter index 2 to array position 2
Outside in loop: Mapped perimeter index 3 to array position 3
Layer ID 56, Outer index 4, inner index 5, second inner index 6, maximum internal perimeter 7 
Inside out loop: Mapped perimeter index 5 to array position 0
Inside out loop: Mapped perimeter index 4 to array position 1
Outside in loop: Mapped perimeter index 6 to array position 2
Outside in loop: Mapped perimeter index 7 to array position 3
New Layer: Layer ID 121
Layer ID 121, Outer index 0, inner index 1, second inner index 2, maximum internal perimeter 3 
Inside out loop: Mapped perimeter index 1 to array position 0
Inside out loop: Mapped perimeter index 0 to array position 1
Outside in loop: Mapped perimeter index 2 to array position 2
Outside in loop: Mapped perimeter index 3 to array position 3
Layer ID 121, Outer index 4, inner index 5, second inner index 6, maximum internal perimeter 7 
Inside out loop: Mapped perimeter index 5 to array position 0
Inside out loop: Mapped perimeter index 4 to array position 1
Outside in loop: Mapped perimeter index 6 to array position 2
Outside in loop: Mapped perimeter index 7 to array position 3
....
New Layer: Layer ID 16
Layer ID 16, Outer index 0, inner index 1, second inner index 3, maximum internal perimeter 4 
Inside out loop: Mapped perimeter index 1 to array position 0
Inside out loop: Mapped perimeter index 0 to array position 1
Outside in loop: Mapped perimeter index 3 to array position 2
Outside in loop: Mapped perimeter index 4 to array position 3
Layer ID 16, Outer index 5, inner index 6, second inner index 7, maximum internal perimeter 8 
Inside out loop: Mapped perimeter index 6 to array position 0
Inside out loop: Mapped perimeter index 5 to array position 1
Outside in loop: Mapped perimeter index 7 to array position 2
Outside in loop: Mapped perimeter index 8 to array position 3
Segmentation fault (core dumped)

[skuep]

Some progress: I successfully implemented this feature for the classic slicer (Arachne still would crash with my changes).
I might test print some parts today..

For the classic slicer, use outer-inner mode to get my new wall order. I have done this to compare against the inner-outer-inner and regular inner-outer modes in a single print.

[skuep]

This is my result. I compared inner-outer (regular), inner-outer-inner (sandwich), innerouter-outer-inner (new mode).

First picture shows the wall with maximal unfavorable lighting. This is very exaggerated and only visible, when the light comes straight from the top. Wall quality is best with inner-outer-inner (sandwich mode), because outer perimeter is printed without any disturbing neighbouring perimeter. This is to be expected .inner-outer has the worst wall quality (this is in-line with what Ellis reports in his tuning guide above). innerouter-outer-inner (new mode) shows (in my opinion) a good compromise between the two. It's not as good as sandwich mode (or outer-inner for that matter), but way better than inner-outer.

Second image shows overhang behaviour. (Un)fortunately the part does not have any problematic overhangs, but the highlighted region shows some effect. inner-outer has best overhang behaviour, and sandwich mode (and outer-inner for that matter) show worst overhang (as is to be expected, since outer perimeter has no neighbouring wall to "grab"). innerouter-outer-inner (new mode) does not have this problem. Looks almost identical to inner-outer (EDIT: Looks almost a bit better at the root of the overhang. Looks like inner-outer pushes the overhang even a bit outside).

My verdict is: I would love to switch from inner-outer to the proposed new wall ordering as my default, since it does not have any disadvantage, but surface quality is better. For parts that require exceptional surface quality, I switch to sandwich or outer-inner mode (as I do already).

[zviratko]

This is great, especially if it could become the default for inner-outer, as most people will just use it (especially now that 3d printing has become accessible to those who have no idea about anything :)). I don't see any downside to it, assuming it doesn't break anything unintentionally...

I am looking forward to testing this if someone makes a macOS build (but I could deal with Windows build as well I think). I have some models that really show the difference like the infinity cube. But I guess the best test would be simply this https://www.printables.com/model/693345-printer-test

[skuep]

I think I agree with the others, this should be a new wall mode, but in my opinion it's closer to the outer-inner mode (just that the first two are flipped), than the inner-outer mode.

I am unsure however if we are getting somewhere in this closed issue.. maybe I am going to try to make a proper/clean feature branch with the changes for the classic extrusion mode (since I cannot get the other one to work) and submit a pull request.

[skuep]

There you go.
#3809

Any idea, how to have the CI/CD system build the binary for you?

[zviratko]

Hopefully, Github Actions will compile it, it just needs the maintainers to approve it
https://github.com/SoftFever/OrcaSlicer/actions

[skuep]

Hopefully, Github Actions will compile it, it just needs the maintainers to approve it https://github.com/SoftFever/OrcaSlicer/actions

The pull request auto build was approved. I think you should be able to start testing now 👍

[zviratko]

Posted some tests in #3809, someone should reproduce and we will probably move conversation there?