Hi, everyone, so I'm here to talk about Fed, yes, we call it Fed, not F3D, please.
Remember that?
So Fed is a fast and minimalist 3D viewer, but I'm here as a president of Fed App Foundation,
which is a non-profit that we created for the project.
I won't talk too much about it, but if you have a question about,
how we did the non-profit and everything, that's very happy to answer.
So, yeah, I'm mature, I'm a mentor and co-creator of Fed,
in the room there is a so-micro, which is also a mentor and co-creator of Fed.
We both also have their jobs, this is something we do on a free time.
I do want to mention that we have a funding that let us do this kind of activities,
as going to first them.
This funding is provided by NNLets and GIS-0.
So you definitely want to check them out,
if this is something you're looking for.
Okay, so let's do a quick test in the room.
So please, once you're in and keep it waste,
if you have GLTF file on your computer.
Okay?
Got a few?
A fix?
Okay?
UST?
And that's a match?
A STL?
Okay?
Oh, yes, that's a more people.
OBGee?
Okay?
Almost everyone?
Step file?
Yeah?
Alambic?
ADC file?
Oh, not that much?
Yeah?
OBGee?
Nobody?
Okay?
We can remove that.
Do you do Gaussian splatting?
Oh, there's one guy.
Nice.
Then I would say everyone is if we need Fed,
because Fed will help you with all of that.
So what is it?
Fed is a fast and minimalist,
really if you were, it's obviously open source.
It's posted on GitHub.
It's a community driven.
There is no company behind it currently.
So we have a very active community of contributors.
I won't talk much about that,
but if we have questions about our community,
I'm very happy to answer them.
We will use every three months,
and we have a very nice website with which
I will share you with our QR code at the end.
Okay?
So what can you do?
What can you do with Fed?
So let's say you just want to quickly visualize a solidified.
So if you usually what you need to do is you go online to
3D viewer or you open Blender, which is very nice software,
but quite big.
You can do the same with my club.
Or you can even go to the dark side and open,
I don't know, my course of 3D viewer,
or any kind of freeware with some others.
That's not everywhere.
Well, of course, you can use Fed.
You can just double click on any of your 3D file,
and you just open it.
That's it.
That's a viewer.
That's what it does.
Or you can use the command line of course,
Fed your file, and that's it.
You open it.
Let's say you want to generate some names for your 3D files.
You're in your file.
Your file browser, your file explorer.
Just want you have so many files.
You're a bit lost,
because you're looking for files and naming.
Maybe it's not perfect.
So there is some solutions out there.
As they have some,
as being existing for more than 10 years now,
there is another project called space thumbnail.
So it's maintained.
But there are all other limitations.
And here Fed is very, very good solution here.
You're basically able to generate thumbnails for all your files,
all the files and machines, all the formats and machines.
In natively, in most Linux distribution,
and it's also natively supported on Windows.
We don't support my quest.
Sorry.
Let's say you want to quickly open CAD file.
Well, you can use free code, of course.
But it's very nice, but also very big software to open.
Or there is a lot of property sites,
a lot of different software.
Many of them, actually.
But you can do that with Fed as well.
Yes, it's the same idea.
You just double click on the file, or use a command line,
and we just open.
Of course, that's for step file,
IDS file, that's the format with support,
currently for CAD.
Okay, let's go a bit further.
Let's set.
You want to integrate the 3D modeling of a 3D model into a script.
Can you do that?
Let's say you have your Python script,
that we generate a JLTF file from a Python libraries,
and let's do that.
And you want just to create a PNG file
from this JLTF file,
because you want to put it somewhere as this image
is because you want to upload to a website,
where you have to have a PNG associated to your file.
But you could write a custom Python script,
that we're actually with the JLTF file,
and then when they're retusing much won't,
or you create your own C++ program in using OpenGL,
and do the rendering, and stuff like that.
But of course, you will not do that.
You can just use FAD, because it's a common line oriented,
so you can just dash dash output,
and here you go, you got your PNG file,
and we recently added animation support in that context.
So that means that if you have an animated file,
that you're open in FAD,
and you output with this specific syntax here,
you will be able to generate hundreds of PNGs,
and then convert that using FFMBG to a M before.
Yes, or what you can even do if you want to go deeper
into the scripting phase, you can use Python values.
I will talk more about Python values, a little bit later,
but this would be the ideal way to actually integrate
into Python pipelines,
that if you need to do some rendering.
And a final scenario is you want to quickly visualize
in the web.
Well, you can actually do that,
because FAD is indeed in C++,
but we do compile it with web assembly,
and so you can just use our web viewer,
and it's on FAD.up, slash viewer.
And if you have an actual 3D model on your phone,
you would be able to connect to that.
If you have a good GPU on your phone,
or you can do that on your computer, of course.
So here we have just an example of opening it's a bit dark,
so you should have switched the background to lighter one,
but you see the points.
Okay, so is it just a viewer?
Because I mean, being just a viewer is fine,
you don't want your software to do this,
and that, and make coffee, and then,
I don't know, make your bed, and stuff like that,
but FAD goes a bit further than that.
So, okay, you open, you open the FAD window,
and you have your data, it looks wet,
but then what can you do?
Well, you can twist H on your keyboard,
and it will show this, what we call that the cheat cheat,
that will show you all this interactive key bindings
that will let you modify the way the data is displayed.
There is actually many of them.
At this point, with Mikael, we're starting to lose tracks
as to how many different controls we have,
because we have the more and more.
And we will soon add a search bar on top of that,
because it's starting to be complex to find what you're looking for,
but yeah, there are a lot of bindings.
And all these options that you do,
basically, crazy things.
Here, we have an example where we have volume of data on the left,
and then using volume rendering,
and some specific color mapping,
we are able, in fact, to generate this kind of rendering.
This is just a volume rendering of medical data,
but this is something you can do.
In fact, which is not something you would expect from us
with if you were up to 10.
And that's just an example.
There is tons of common item shifts.
And all these options that you can do from the common line,
all you can do, interactively,
you can also control from a configuration file.
So that means that if you are always using the same options,
always using the same interactions,
you're able to just put that in your configuration file,
and then the next time you open file,
it will just look exactly the way you want it to look.
And you can match it with different extensions
or different, even, fine name.
So that's your configuration block,
or specific for each of your files.
So this way, you know, oh, this is my GLTF files.
I want to learn things like this,
and my stepfile, I want to learn them differently.
Okay.
So that is also a very nice documentation
that we actually write all of,
we just tried to make it as good as we can.
And this documentation is available on our website.
It's also available as a dash-l,
but it's much, much more complex,
complete on the website.
This is a searchable website,
so it's very easy to find the information you're looking for.
And we even have version,
help, so you can look,
if you're demanding the version you have,
you can look on the website.
So there is a QR code here,
but it will be available at the end of the slide as well.
Okay.
So what kind of options can we use,
and what does actually exist in terms of options,
in fact?
So here I've selected a few of the,
I would say most interested option,
but there is many other,
I will not talk about it.
If you want to do something,
just ask,
and I will let you know,
is it possible or not?
Okay, so animations.
This is something that,
of course, if you do CAD,
that's not what you think,
but if you do GLTF files,
of course,
that makes a lot of sense.
So yeah,
lighting is that great here,
but at least this one looks great.
So you can have multiple animation,
in some format,
you're able to select the animation you want to show.
You can control the speed,
you can go frame by frame.
So which is very useful,
when you have low resolution animation,
like we do CAD,
on the top right,
which is a,
it's a doom model,
which is like just a few frame of animation,
and you can go frame by frame.
Okay, textures.
So when you load GLTF file,
which is okay here,
it will load the texture as well,
if they're available.
Sometimes they're baked in the file,
sometimes they're a PNG files,
which are on the side,
but it will work automatically.
But if you want to force a specific texture,
because you're working on the texture on a PNG file,
on the side,
you can just side load it with a common line option.
So you just modify it at the first,
I'm not going on it,
and just, that's it.
With support, FDRI.
So FDRI is a way to add some kind of a,
360 degree is background on everywhere on,
in your scene.
So this HGRI,
we let you not only add a background,
if you want to show it,
but also to light,
your model using this HGRI.
This lighting,
we give very, very, very much nice,
more underings.
It looks very realistic.
I mean,
it's not very tracing, of course,
but it looks much better with an HGRI,
that without an HGRI in terms of lighting.
And you can even blur the HGRI,
so that it looks a bit nicer.
And if you don't know where to find HGRI,
to do this kind of nicer rendering,
you can download it on the web,
there is a website called PolyEvan,
which provides HGRI on the CC zero license.
So this is very useful.
Okay, so you can also do multiple files.
So as of now,
I'll only show you how to print a single file,
but if you have multiple files that are,
for example, part of a bigger,
a bigger model,
forcefully printing, for example,
where you can just open them all together
into a single view,
and this is exactly what I did here.
So here we have,
I don't know,
maybe 15 models,
that actually,
if you open it with a multi-final mode,
it will just show up as this single model.
But it's actually multiple models being loaded.
And we actually have multiple multi-final models
that you can actually use a regax
to choose how you want to go by and stuff like that.
In terms of advanced rendering,
we of course suppose,
support blending,
if you have opacity on your files.
So here on the left,
without blending,
toned down,
you of course it's all mapped up and everything.
And on the right,
we have the blending correctly set up,
so that you can actually see through,
because there is some opacity on the parts,
but it looks correct.
As I've actually different blending modes,
I will not go into specifics,
but if you have questions,
make it would be available to answer that.
We have so support ambient occlusion,
which is a way to have fake shadow on your models,
and that's look very great for this kind of model.
Here we have some intricate geometries,
you actually can understand much more outwards.
Okay, so this one is a video.
We also support Gaussian splitting, that for you.
You can actually open your Gaussian splitting files.
So there is PLY,
the splat, the SPZ,
that you can open,
and it will just show up like this.
So if you don't know what Gaussian splitting is,
I will just explain in less than a minute.
It's basically lots of points with some kind of shapes and colors,
but it's an interactive photo,
where you can move around,
unless you stay kind of at the same location,
where the acquisition of the data
was made by some kind of a specific camera.
And yeah, this is not really supported in fact,
and there is actually not that many viewer that supports that.
It's a specific thing.
You can also do some analysis.
If you want to know how many nodes,
how many cells,
the bounds of the scene,
you can use just very simple tool to do that.
So here we have,
you can show in the scene the number of points.
And in the terminal,
you can have many more information,
for example,
the name of the animations and stuff like that.
So you can use it as an analysis tool.
And you can even, from the command line,
say you don't want to do an actual render,
you just want to,
when it without rendering and just,
oh, give me some info about my file,
basically,
you can definitely do that in that very useful.
And we also have scientific visualization,
which is kind of a specific thing for us,
with the viewer,
but it's explained by the history of the project,
because we basically started with that.
That was the first features we had in the project,
like,
because we come from a background of scientific visualization,
mechanics,
so that's why.
So yeah,
you able to,
shows a column up on the surface of the model.
If there is a data on the surface of the model,
to show column up with,
and you can also do volume rendering,
here's the same idea as before,
where you able to do volume render with,
with a different colors and to blending with the,
with the depth.
Well, is that it?
I mean,
that's a lot of features.
You can use this very simply,
and there is a ton of features that are available,
if you want them,
we do not,
we do not force them to you,
it's just the here,
you use them,
but there is actually much more.
First,
Fed is plugin based.
That means that all of our dependencies,
except VtK,
which is a main dependencies that you need,
all of our dependencies are optional.
So, if you build,
you yourself,
you don't need to actually enable all of these dependencies,
if you don't want them,
if you don't need them,
so you will end up with less complexity,
of course,
because you don't need to build,
let's say you don't want CID,
you don't do steps, you don't do HHS,
and you don't need open cascades,
then you don't need to enable open cascades,
and then you have a simpler build system.
So,
we have that for all of all our dependencies,
you can turn them off if you don't want them.
And,
you can also use this plugin mechanism to create your own plugin.
If you have your own file formats,
that you want to create a plugin for,
and you want to be able to load your own file into Fed,
to do some renderings,
you can easily do that,
and someone already did.
We have Abacus plugin for Fed.
Abacus is a proprietary library,
that's for to open this kind of file,
which are Abacus files.
Of course, we cannot ship it with our bandwidth,
because it's proprietary,
but someone did that,
and they are able to view their Abacus files.
Okay,
and another thing that you can do,
is that you need to understand,
is that Fed is not only an application,
but it's a library.
There is actually Fed's application,
and the live Fed,
which is a library that is inside of Fed.
And this library is actually shipped in our binaries,
or if you build yourself,
or of course, Abacus 2s a library.
So it's simply 17.
And here,
the example here,
or not for you to actually read,
I don't understand,
it's just to show you,
this is the number of line of code you need,
if you want to show a window of Fed,
with a model inside of it.
That's actually six lines of codes.
And another,
another one is another example,
that's a different kind of example,
where you don't,
you have interactivity or not.
So yeah,
that's,
where it is,
there is not much more to it.
And it is also available in Python.
So here,
I have an example in Python,
to do some kind of interactivity,
wondering,
with Python buildings,
and it's available on Pipi,
you can put in Stalfet,
and you just get the Python buildings,
and you can start import Fed,
and that's it.
It is not super clear,
so if it was a contrast,
but it's basically someone writes,
Python script using Fed,
and then they wonder,
in two of the time you're using Python.
So that's a specific use case,
but that's funny that it's actually possible to do that.
And here are some showcase of things
that have been done using the Python buildings.
So you can have nice camera movements,
because you can control the camera,
using the bindings,
so you can just move it around,
using your own camera pass.
Here we have an option that I'd not talk about,
which is called Final Shader,
that lets you run an OpenGL Shader at the end of the rendering,
to do this kind of stuff.
And here,
the compositing is not done,
with Fed,
the compositing of different images,
but we did generate all the pages,
and these are compositing using another tool.
So all things you can do,
which are actually quite easy to do with Fed.
But I talk about Python buildings,
but that's not it.
We actually have C buildings,
Java bindings,
and of course, Java script binding using WebAssembly,
in order to be able to do the web version.
And the C binding have been truly important,
because we have already seen people creating Julia bindings,
and we have someone else working on Web bindings,
and this will not be impossible without the C bindings, of course.
So if you want to give it a go,
I'm sure you will find a way to use Fed
even if you use some kind of special language.
We'll find a solution.
Fed can be integrated into existing applications.
We have examples for that,
integration into QML,
integration into QUT, into FLCK,
this is just an example we managed to put together,
but I'm sure any framework in any framework
you will be able to use or API
to integrate into your own application.
And this way you would just be able to integrate a window
to show a 3D model into your application,
without the need to write any kind of 3D model
reading or wondering.
There is an example of that called Exhibit.
It's actually pretty well known application at this point,
because it's part of the GNOME ecosystem,
and there will just be people using Exhibit without knowing
that there is a backend to it, which is called the default.
But that's what is made for, right?
Okay, and in terms of perspective,
what are we cooking right now?
So there is a big plan to do Android app.
So here we have the example of the Android app on the right.
It's kind of working,
but we still have a prototype working,
but we did not realize the amount of work
to do something that is clean and quick and cheap.
So it will come in 2026,
but we have no dates in mine yet.
And there is also IFC support.
So I'm not sure if you do IFC files,
but this is something that is happening
in three months.
The next question we get IFC support.
So this has been requested by the community for a long time,
and we are very happy to be able to ship it very soon.
Yes, that's it for me.
Very happy to take any questions.
Yes?
Cool.
This is amazing, and I have so many questions.
I'm going to chase you down.
I've got a lot to talk about,
but a couple specifically.
So I want to do everything to serve aside.
So I want to do rendering three models for preview,
which is on the headless serve.
Okay.
If the time when dealing with graphics,
you need like a display context.
Can it be done?
Absolutely.
Amazing.
You can use IGL or OSMESA to do some rendering.
OSMESA is out of luck now,
that IGL using CPU is coming up,
so anywhere you can use,
and it's also dynamically loaded,
so you don't need different executable or stuff like that,
because we don't link with the intel.
So you can just, you can actually,
there is an option called dash dash for rendering back end.
When you say, you can only use,
and if you don't say it,
it will be automatically tried to find the right one.
So, yes?
Brilliant.
Also, is anybody working on Ruby behind things?
If not, I might.
So, thank you for this works.
So, if I were to write plugin for something super,
super niche, would you want to have it?
If the specification of the format of public,
yes.
If this is your own internal format,
that nobody can write file for.
No.
But, we will advertise that this plugin exists,
and patch your link to your GitHub,
or to your repo, anywhere but.
Okay, that's great.
We have reverse engineering,
an old game,
and it has its own model format.
Oh, which game is it?
It's like there was this old touch publisher,
called Derby Lex.
No, I'm not made.
They made like racing games.
Okay, okay.
I'm trying to figure out how I make the models
more visible to me,
and this would be great.
Yeah.
So, with reverse engineering,
that is always a legality problem.
So, if that's clear that the code is legal,
yeah, no problem to integrate it.
But, yeah, that's just the one thing that on top of my mind.
But, if it works,
if you have put the specs that you will be basing
a little bit somewhere,
so that the people in your community can use,
of course, as you can see,
we support QuakeMDL,
which is Canada-Nish.
I would say, I mean, the people from the Quake community
are super happy to get it,
but nobody else care about it,
but we are very happy to have made it.
Because of spec or like everywhere,
you can find them on different websites.
So, that was actually,
is that made sense for us to add it.
Okay, thank you.
Short question.
Is the next presenter here?
Okay.
It's supposed to be graphite, I guess.
Okay, I can have more questions.
Do you do anything about export of models?
No.
This is something we consider adding.
The problem is that,
whiting an exporter is another story
and a reader.
So, maybe at some point,
someone we could improve the leapfade
to be able to have some kind of export back in,
and then write another project
that would be using the leapfade to do the
importance and the export.
Yeah, it's a lot of work,
and not really in the planning.
Can I jump in with my own question?
So, as a beginner,
this, I mean, it looks like a very interesting project.
You mentioned there was, you know,
you can do it simply through Pip and I Python.
Yeah.
So, is there good documentation,
any sort of tutorials online on how to get started
with creating your own?
Yeah.
So, we do have a page dedicated to how to use
the leapfade in Python.
To be honest, it could be expanded,
but we do have, in our website,
an example to show that,
and then inside the repo,
you have an example, directory,
that contains five or six different examples
on how to do what you want with Python.
And we are also dedicated with a little bit,
called FedPitonX2az,
that is maintained by someone in our community.
And in this Python module,
they use that actually created small scripts,
and small utilities that let you do,
you know, the movement of camera,
stuff like that, it's actually baked.
Yeah.
Cool.
Thank you.
Oh, we've got a question at the back.
Also, do we, I think we've got our next speaker.
Sure.
We're all about it.
One last question.
That's the very best one, though.
Yes.
Thank you.
Just wondering about how dynamic it is.
Like, you showed it at the end
that you can animate the camera.
Yeah.
Can you actually animate the 3D model, no other thing?
Yeah, absolutely.
Maybe there was a clear, but I had a slide on animation.
You can definitely do your animation.
Some formats are more optimized and also.
For example, we do have a screening and morphing
baked in the GPU.
In GPU rendering for certain formats,
but not for other.
So that really depends on the format you're using.
We try to make it as good as possible for animation,
but set in formats, let us do nice things for GPU
rendering.
Also require to just move on the machines,
stuff like that.
And you can do it from the API directly.
Yeah.
Thank you.
If you want stickers, we have stickers here.
So grab your sticker.