All right, good afternoon.
Welcome back to the Fossum 2026 Open Hardware and CAD CAM Devroom.
Up to this point, we've seen a bunch of projects that
depended on Open Cascade.
So finally, at long last, we have Dmitry from Open Cascade
ready to give a presentation about the upcoming 8.0 release
of UCCT and Open Cascade.
Yes.
Hello.
Let me just try.
Do you hear me?
Okay.
So, unfortunately today, I will not have a few more.
And not so much pictures as previous speakers,
because, unfortunately, Open Cascade is not a application.
It sounds like more complicated.
It is SDK.
This is how specific you go.
I prepared for to be used.
So, I will try to be as simple as possible,
but I will be no pictures.
My pleasure.
So, let's start from the beginning.
So, as someone mentioned before, Open Cascade
is mostly one of the available open source CAD
Qernels, which work in the CAD Mesh and a few more options.
And it's just as used behind, not very visible,
because a lot of projects, hundreds, maybe thousands of small projects,
big projects.
They can be done on the, as you see on the desktop application,
can be on web.
It can be even on small devices.
Why?
So, it's very powerful.
And give you a lot of availability to be used
on different projects, different areas.
By default, let me just show you something.
OCCT itself has a very long history.
It's starting in the first year.
It's starting from the University from French,
but it's a clear, which specific date.
So, but in the first year, it was released as a first,
it was out of the grid.
So, and it was used.
Currently, we have about 3 millions of lines of code.
And starting from 1999, Open Cascade was available
as open source.
And now, privately hosted grid,
because it was not used.
It was start to us, as we read.
But, yet, 27 years ago, there are no, we don't know,
we don't know, we don't know.
Fortunately, unfortunately, but here,
we go early, isn't it?
And the interesting fact, for example, a few years after
we saw a grid, the application was used
for the physical simulation, physical researches,
and in the company name, as a current,
it's French company, governed based,
which developed and detects,
as a hand-bison,
hand-bison.
So, it was used for preparing all the instruments,
all the tools, visual CT.
It's not a CT, it was company name,
it's Matta Davision, which have a long history,
but it's not a major layer later.
It's just something,
what is cut-cure-nosef,
cut-cure-nosef application,
as a cut-cure-nosef,
it's used very complicated,
but it's behind everything.
So, we have foundation classes,
it's something we're providing
to be on the same page,
with all the modern projects,
containers, memory,
modeling classes,
modeling memory math,
and all the work in this application system,
it's system dependent.
So, very sensitive stuff,
we have modeling data,
we have modeling algorithms,
visualization,
and it's probably the deepest,
later it's that exchange,
application framework, and test the harness.
It's not so deep and used,
not so commonly,
but step is used very often, mostly.
From the projects that we're hearing,
they are using step very often.
So, currently,
probably sometimes you hear open cascade,
and it's this 3D.
The difference is,
both of them,
but of consumerized,
starting from the 2000s,
and then 14,
and nowadays,
starting for about two,
three years ago,
the branch was split it.
Now we have open cascade,
it's possible for the enterprise project optimization,
as a model,
and it's currently not open source,
it's enterprise-based,
it's for the very,
and totally-based,
it's much modeling,
and other interesting stuff,
which is very powerful,
but it's not open source.
And we have, for this 3D,
is a branch,
who is responsible for maintaining the category,
and also is the project.
It can be open source,
it can be private source,
it can be different forms of the source.
It can be also some free application,
which can sometimes be used,
quite a system, probably,
often used by the community.
So, history,
as I say,
open cascade was started about 45 years ago,
then it was,
become cascade,
when it's just a little half,
some matrix with,
on the desk,
it was another company,
a full-gold name.
So, yes,
so it's,
what's the little written on the 193,
then it's updated data,
it's open source,
on 99,
before 20,
2013,
it was terrible code,
because on these times,
open cascade was having the,
which is,
which is it,
it's very complicated,
not available to be used,
and most project,
also,
the intensity was based on the work build system.
It's very,
it's started from the 96,
so it's very complicated,
the solutions to build,
the,
the currently,
it was moved to CMA,
but was,
before it wasn't work,
all developed platform.
And for the header files,
we have ID,
H,
it's headers,
but not C++,
it's more complicated one,
it's intermediate formats.
So, on,
well,
literally,
it's algebra,
everything was really,
10 multiple times,
and on 2016,
open cascade 7.
Something was released.
So, during this 10 years,
we are having a lot of fixes.
For sure,
I don't see all of them,
we can just,
close this,
so,
it was a lot of work done by the decade,
and it's now,
it's next decade,
so,
you see,
it's already 10 years ago,
and it was a lot of changes,
was done,
I cannot read of them,
because I tried to be fast them,
and it's not so interesting,
because I've already done,
it's available for you.
So,
yes,
we have every year,
one,
one maintains,
one,
minor release,
and,
for the decade,
we have one major release.
So, let me just,
maybe,
would like to have something interesting,
at least starting from 7.8.
No,
it's just 7.
So, yes,
so,
starting from the 7,
we write a lot of code of 6 also,
yeah,
maybe 7.6 is more interesting,
because starting from the 7.6,
open cascade,
was able to run on the area,
and also on the web assembly.
So,
starting from this year,
you are able to work with the city,
on the web,
as the vast assembly.
Currently,
starting from the previous year,
the performance on the web-based application,
it's close to 95% of the desktop one.
So,
performance across memory is not limited,
no longer,
because 64 meg,
by it's 64.
So, web assembly is also big step,
then we have 7.7,
where we update all the code base,
to be back like a party,
but with all the modern C++,
then we add the general interface,
to read with all the data formats,
and we have just a compression,
sorry,
but that's interesting.
On 7.8,
we add memory management,
we rewrite all the code,
to be in the same memory space,
we add a little more to the steps,
secure,
set,
set safety,
but it's not still good.
We still working on it,
we add the plugins,
we rewrite all the repositories,
structure,
not structure,
the little kids names,
and 7.9,
we decide that we need to
little go with our old code.
We need to a little modernize,
a little improve,
we perform as a good,
the big formatting,
over-sync,
we perform a lot of type,
an example,
a kind of format,
we integrate,
and not currently maintains
our fork for the VCP package,
which a lot of community use.
And nowadays,
the most important stuff,
open cascade,
was me great fully to get happy.
It means you're able to provide
the public rest,
you provide the feature request,
back report,
everything can set get happy.
And in most cases,
you can just take me,
or I'll allow developers,
and they will respond to you,
whatever,
in the site,
our visitors,
and set your visitors.
I hope you will have this,
you will use this package,
because currently,
we have not so much back report,
so we don't have bugs,
perfectly.
So I hope you will have more bug for us.
And yeah,
starting for the coming version of 80,
we would like to have a little more updates,
because currently,
we have too much old code,
which was,
very old.
So it's starting for the beginning,
we still have very old code,
which I sometimes just,
see,
I don't want to see that anymore,
but I still have a few changes.
We're using free base,
so we cherry pick,
and one changes,
it's one changes.
So,
some repository,
use multiple comments,
but we use one feature,
one comment.
That is wise,
and amount is not so big,
because we consider it,
and combine everything in one comment,
to be very clean,
and very readable,
the git structure.
So, currently,
if some of you are developers,
you probably know that,
if you want one set,
type of city,
you know that we have everything inside,
so we have how much modules,
we have how on standard types,
every single stable,
for the new developers.
Now,
currently, we go out from all the old stuff,
which use for walk,
and for adh,
it's old stuff,
which would no longer support,
but it's still was here.
So, now in days,
you can use just plus plus 17,
and you will be happy,
at least I hope so.
So,
also, if you're using our data maps,
it will be more comfortable to work with them,
with buildings,
with,
from 17,
as a feature,
a lot of developers say me,
why we don't use just plus plus container,
from the STL,
that's terrible.
The performance are bad,
the control are bad,
especially with all the stuff,
related to the memory allocation,
destruction and construction is terrible,
and,
I just don't want to go deeper.
So,
this container is not so friendly,
but they were better.
The benefits of it,
on 7,
on 8,
we will have a pass-out.
Pass-out,
it's just pure STL,
unlike STL containers,
which behind have all containers.
It needs interfaces,
the same,
but behind it's all containers,
because I don't want to see them,
the STL any longer in the STL,
I remove everything from.
It doesn't prove,
so,
I really data a lot of stuff,
but here,
a big careful,
if you have STL,
sometimes it's not a good choice,
for the high performance applications,
a big careful,
just try to use profiler bay night
and you will see what's happened.
You will hate that also.
So,
source organization,
before on the main folder,
SRC,
we have about more than 500 folders.
When you open the folder,
and see 500 folders inside,
maybe you think something can confuse you,
but fortunately,
no,
it was something wrong with us,
but it's something legacy from the work.
Nowadays,
there are just five subfolder,
it's a folder,
and the logic is simple.
Now we have model,
SRC,
model,
toolkit,
package,
files,
just final files,
everything headers,
source files,
everything's clean,
and a lot of the features of that,
if you're using,
like,
kapile,
or cloud,
it's very powerful with this layout.
It's nowhere,
it is,
and he know how to grab and parse it.
Much better for,
at least,
looking for informations.
Much clear,
and also,
somewhere,
a lot of readme,
md,
for the folders toolkit,
and so on,
sometimes you will see them,
and I plan for the next few years,
we'll add for all the toolkit's readme,
because probably developers would like to see
a little more information.
So,
hopefully,
open cascade was tested all the time,
so fortunately,
we have the testing for all these decades,
and yeah,
it's good.
So testing is important,
and I hope all the application
have their own unity or integration tests.
Integration,
not hence,
and basically integration,
but just script applications,
script based testing.
So,
apparently,
we have all the Google tests,
so,
from the 7.9,
the support in Google test.
So, it means,
it's some developers would like to integrate some patches,
they can use POS,
but what's called,
they don't need to go deeper with TCL.
TCL,
it's our own script based,
TCL is not ours,
but we have our own script based application,
which based on TCL language,
by GitHub CICD,
for the all-platform,
fortunately,
or unfortunately,
it's only about 40% of all the tests.
All the other tests,
we're going to commercial private stuff,
but it's enough for the community to be just seeing
what's wrong with the patches.
You see the reports,
you see the differences,
picture differences,
simple memory differences,
you see everything,
everything available for you to see,
and it's also CICD checks,
the code quality,
and all the stuff by the public list.
It's perfectly work.
For the data exchange,
I will have,
I hope it'll long topic about the forms.
Yeah, I have the time.
So that exchange,
open cascade by default of CICD,
sorry about that,
CICD,
it's company which I currently,
it's part of the,
I'll keep jamingy,
which currently is brand.
Yeah, thank you,
check.
Which part of the brand?
And yeah, CICD.
So we have open source formats,
and we have commercially commercial formats,
each available by commercial news.
But yeah,
open source are available to,
buy all the community,
and they can use it.
So dry,
map,
you can,
not map,
a lot of names,
but yeah,
the most important step,
and probably,
nothing more.
Yeah,
so,
as I say,
or CICD,
it's very complicated,
have three million lines of code,
no one wants to read them,
no one would like to use them,
if it's not necessary for them.
That's why,
we decided to go forward with something simple,
simple.
So we decided to go with very light,
this is a C++ new repository,
which will wrap everything,
but just provide a very tiny API,
and it's very high,
the commented.
So that is why,
I hope it will be much more for the newcomers,
and at the same time,
it will provide a much language for rappers.
And yeah, so all the CI,
API for all the rapid languages,
will be the same.
We will use our own personal rappers,
not just something,
but yeah,
so it will be used,
and then,
hope it will give best benefits for the community.
So the roadmap,
for the long-term and medium-term and near-term.
One of the benefits,
I remember that,
yes,
on the chat,
on this conference,
so as a chat,
if you don't know,
there are a lot of questions about
why land for the kick-out,
and yes,
why land will be added for the open cascade,
starting from a few weeks,
oh,
for the list,
so for the list,
a it's zero,
why land will be supported to be used.
So,
it probably is,
as you know,
the free image is no longer supported,
we need to go out,
because it's insecure,
it has a lot of gaps inside,
if you are using free image,
be careful,
it's dangerous for your application.
It has a lot of holes.
So,
we would like to,
so it's probably new.
In the medium-term,
we would like to inform you that open cascade,
currently preparing the new formats,
with public schemas,
for the two formats,
just base for the shapes,
for the formats,
which will be 50 times faster,
and smaller,
till we have the binary and JSON presentations.
It means that you have public schemas,
it will be very fast,
and it will be available for all of them,
all of you.
It will be documented,
it will be used,
instead of the current break.
Break also will be used,
but that will be supported for the shapes.
Also,
we will have Samsung PDM related to the formats,
which module,
which module structure,
to be added as a plugin,
all the necessary stuff,
which you're going to create on your side.
It will be something
from the medium-term,
so it's very interesting for the most of the community,
because the formats,
is currently something complicated for the community.
Oh, the interesting stuff.
I forgot to mention that
starting the previous year,
OpenCascade was become a member
of the lot of organizations.
I was trying my best,
and one of the organizations
is kind of a limitation for them.
So it means OpenCascade,
currently on weekly basis,
participate in the improving step.
So with the guys with all the,
I don't know how to say this,
flag amounts of the industrious,
we just come back together,
discuss and talk in what we can do with this step itself.
So a long tour,
we would like to implement WebGPU,
we'll come,
a common organization,
a multi-streaming spreading,
so currently,
we're going to be very complicated,
and see,
I would like to minimize the exception dependencies.
So,
I'm trying my best,
because I'd like to talk about your QA,
and so,
as I say,
if you have any problems,
if you have any ideas,
go to GitHub,
create feature,
discussions,
create the pull request,
I hope you will do that.
And just,
yeah,
unfortunately,
for the pull request,
we need to sign the CLA,
it's will not obligate you nothing,
but we need to do that.
So,
all the activities like feature requests,
back request,
discussions,
you'll free to go,
but for the pull request,
if a little more your time for the doses,
all the activities like integration
will be on us,
we just provide code,
and we do everything for you.
And, yeah,
is this all?
I'm welcoming any questions,
and I hope you will have some.
Thank you.
You did a very good job,
leaving time for questions.
We have lots of time for questions,
so,
Clement.
So,
about this light API that you're proposing,
is this intended to kind of grow and have more functionality,
and eventually replace the API for everything,
or is it meant to stay small?
It is modular.
Whatever I do is modular.
Oh, I forgot about some features.
Yes, it will be modular.
It means you can add a lot of modules inside,
including the extra features,
which we have a lot of community around,
and we try to integrate them in the same layout.
So, it will be modular.
It will have more functionalities than original C++.
It will be modular.
So, I'll see++ for the,
for the Samsung,
which are found to mental,
and everything plugin system is on.
It will be on the,
this flight of city.
I have seen the example you have shown
about the Python code from the light API,
and I'm also using Cuffvery,
which uses a similar API.
But as far as I know,
Cuffvery uses some kind of repair for open cascade.
So, do you think that we're probably probably
be,
we don't need it anymore in the future?
So, Cuffvery hates me.
Ah,
Yes, we just can't talk about this community.
So,
as the problem is,
I have a work out of a city,
and they have troubles with migrations.
I love them.
So, sorry.
So, Cuffvery is all unwrapped,
and the structure they have wrapped,
I don't like.
So, the interfaces for the city light,
will be totally different from all the rappers,
you know.
It will be totally different
because we need to something different,
which more future proof,
and much more simple to use.
All the git rappers are not that good.
They work in,
it's fine.
But they need to be better.
Yeah.
Ah, yes.
I tried to help this team to migrate.
So, yes.
Cut query.
We're in touch.
Ah,
So, my question is about
GPX variation.
What are you
intending to use GPX variation for?
Yeah.
Ah, it is mostly for the shaders.
So, we have just,
at the moment, open cascade is
breath based.
So, there are no much possibilities to do.
Most of it will be done in our commercial sites,
about the intersection,
and the collection,
and some of the stuff,
but it's for the mesh based.
For the brief based,
we only for the,
not brief itself,
for the visualization.
For the grid rendering,
and so on.
Because sometimes we grid create
by the currently,
by the shapes.
It's bad.
And just,
more jippo by shaders.
And just ten years ago,
we removed to the,
and as a type of pipelines.
But yeah.
We did it.
So, it just was a very, very, very interesting mostly.
Thank you.
Yep.
Hi.
Thanks for your talk.
From your perspective,
would you have any advice for
freecat,
but also other open source projects
that are making use of open cascade,
in general,
given the roadmap.
Yeah.
So, the main point,
I would probably prefer to have,
for the all the community which has used us,
is used in the future,
develop a much easy interface
to get the data from our step,
for example.
For now, a lot of community missed
information about dimensions,
layout, layers,
and all the stuff from the step.
We have it,
but they can't extract.
So, my recommendation just,
at the moment,
all the APIs complicated.
We would like to improve it.
And my recommendation,
please provide your feedbacks.
Yes.
Your feedbacks,
and we will discuss all the possibilities
to improve us,
and I hope we will help you
as much as we can.
Yeah.
Thanks for the presentation for your work,
especially.
I'm not ready for a million
with the internals, so I've got the kernel.
Fortunately,
but I was wondering,
like, this is like a overview question,
like,
the main difference now
between,
or this is 3D,
and something like,
parasori,
it is more like,
performance,
or feature,
or something else.
Ah,
yeah.
It's complicated to say,
but everything.
So, we have totally different models
of to be used.
Performance,
it's complicated.
Sometimes we have better performance
because we have much less,
or,
all features,
which we need to keep,
because we have freedom.
We have no limitation of contractual stuff.
We can just,
just,
keeps,
don't keep something.
The difference is,
amount of people working the project.
So,
copy and cascade have a kernel,
but feature around,
I'm not that smart as much.
So, parasori is powerful,
because they have a lot of,
functionality at the top of the kernel.
So, they have a lot of features.
They have a thousand of people
who are using QA,
and so on.
The difference is,
mostly,
about just community around
and development team.
They are similar,
very similar,
because they are working with both.
I also touch,
or not,
sorry.
Hi,
I just wanted what the main barriers
were to the GPU acceleration,
point for the long term.
Is that going to be like,
short long term,
or like,
really long long term?
Ah.
It just depends on the community,
as I say,
we don't have sounds with people,
and we need to prioritize.
This is kind of a low priority fast,
which I would like to have,
because it's problematic for me
when you have grid,
and it's kill you performance.
I very sensitive with performance,
and for the last few years,
I improved with CT,
and in total we have about,
for example,
step files was improved by 95%
and big files,
reading step files.
It's a lot of performance overall.
We improved by CT,
by tests.
It was improved by 20%
just with starting tests,
and the 20% faster than two years ago.
All the tests.
So I very sensitive with performance,
and that is why only one is.
There are no more problems to do this,
but slower priority.
Okay, thank you very much.
So maybe for the community,
so if OCT needs help with our input,
so I'm being paid by the FreeCAD project association
in the position as OCT layer is on,
and so I try to interact with the FreeCAD community,
but also with open cascade community.
And yeah,
if our feedback will help,
then I can be perhaps also a middle person
in between to help make this smooth or,
yeah.
So if you want to reach out,
you can probably just find me the position as OCT layer on.
Yes.
So you can occupy the GitHub of FreeCAD and use it,
and I will just grab visit using the help of FreeCAD.
So you can occupy their space.
But I will have more reports.
Thank you.
Yes.
Also, while forgot a few topics,
currently,
main topics is modernized code base.
So currently,
we rewrite a lot of foundation classes like the solvers,
or the matrix solvers,
linear solvers and so on.
It was totally rewritten,
and soon we will rewrite much more
because I like performance and code quality.
I rewrite a lot of them,
and they are faster, better,
and looks better.
I hope much people will be sure that not only me.
Okay, some more questions?
Well, two questions.
My question would be about the API again,
because my impression is that
because you said that the JavaScript and Python API
would be much wider in the end
than the SQL-class API.
The path for new code projects would be to write themselves
in some of those languages, either Python or JavaScript.
Probably you don't get my idea.
So, say,
Lighter City is C++ projects.
It's the same C++,
but simply project projects.
Everything like wrappers will wrap
this C++ projects.
It means the interface for the languages will be the same as C++.
It means C++,
it has the entire interface,
as Java, as Python, as JavaScript.
It will be the same language,
but the basic will be C++,
just because it's better for this world, it's better.
Okay, so,
the base design API is written in C++,
and then just adapters for the article.
The documentation will be one,
so the documentation one,
the function will be the same.
You will write by different compilers or interpreters.
Last year,
there was a talk here,
if somebody using this web assembly
was some version of OCCT
to make a web-based cat.
I looked into that,
and one problem with it was it's like a gigantic download
every time,
and you were talking about modularity.
So, is it possible to cut that down?
And how would this work?
So, it's already worked.
So, the modularity,
it means you have full flexibility,
what you want.
So, there are a lot of lags,
and you can just disable it.
I don't like cat docker,
so it means it will be work on any platforms,
you can just choose what you want,
and it will choose and wrap on these features.
It's very light,
and a lot of people who give this for the temporary changes.
You say it's much, much smaller,
and much easier to build,
because a node docker is like done for the OCCJS.
OCCJS no longer supported,
and the API is terrible.
Sorry.
Other questions?
We have a couple minutes.
No? All right?
One more.
All right. Why not?
What would be like the use case for whale and support?
What has to be done for whale and support in OCCJST?
Because if it's a library,
then shouldn't it be like,
should it be not responsible for output to display?
We work a lot of the...
What is the use case for whale and support in OCCJST?