- Who is using yFiles, already?
Customers from almost all industries all over the planet have been using yFiles for nearly twenty years,
to create both internal and customer-facing applications and tools. Clients include both single developers
and the largest corporations and organizations in all of academia, public and governmental services,
and of course, the commercial space. See the references for a non-conclusive list. Naturally, there are the big well-known software corporations among yWorks’ customers
(unfortunately only some of them allow yWorks to list them on the references page),
but there’s also a great lot of companies that are not traditionally known for software, but who still have their own
IT departments create software for their intranet or customer-facing applications. And last but not least,
smaller companies without IT departments that let third party implementors create useful diagramming applications
with the help of yFiles for them. yFiles at its core is a generic diagramming component that is use-case agnostic
and can be used to create graph and diagramming-centric applications for any business domain that requires working
with or displaying connected data.
- How long did it take to implement yFiles?
yFiles started as a university project at the University of Tübingen in the late 1990s. Since 2000,
yWorks has taken over all development and has been working continuously with a core layout-team of two to eight developers
on improving the layout algorithms. The layout algorithms alone, as of 2021, took more than seventy development years to implement.
A team of more than 25 developers has been working on the implementation for the visualization and interaction and the
support for the various platforms yFiles supports, totaling in more than a hundred years of development for the visualization.
Porting yFiles to a new platform in the past took between three and about 15 development years. Most platform variations
were implemented in between six and ten calendar months.
- How long has yFiles been around?
yFiles started as a university project at the University of Tübingen in the late 1990s. The company yWorks was founded
as a spin-off of the university in 2000 when the first commercial customers wanted a license for yFiles. Since
then, it has been developing and improving the library. It all started as a Java library, and over time, yWorks improved and
even rewrote large parts of the library to add new features and support new platforms.
- Who is the company behind yFiles?
yWorks is the company behind yFiles. It was founded as a spin-off of the
University of Tübingen
in the year 2000 specifically for licensing and supporting yFiles commercially. The German company is a privately-held,
headquartered in Tübingen. More than 30 employees are working at yWorks, over 20 of which are developers,
working on yFiles and the tooling around the libraries. The library developers also provide support and
implementation services to yFiles customers. So as a developer, you will get first-class, highest level support
directly from the team that implements the libraries.
- What does yWorks specialize in?
Since 2000, yWorks is dedicated to the creation of professional graph and diagramming software libraries.
The software yWorks creates, enables customers to realize even the most sophisticated visualization requirements
to help them gain insights into their connected data. Their main product is the software programming library family
yFiles, which is the most sophisticated and complete solution available for
diagramming applications on the market,
supporting the broadest range of platforms, integrations, input methods, data sources, backends, IDEs,
and programming languages. yWorks has set a track-record in providing the most extensive layout and diagramming
solutions for developers on all major platforms. In addition to creating, maintaining and supporting the libraries,
yWorks also provides professional consultancy services in the area of visualization and diagramming.
In addition to that, yWorks also provides a set of smaller software tools, both free and commercial,
end-user facing and for software developers, closed-source and open-source.
- Does yWorks own all the intellectual property for yFiles?
yFiles does not depend on any third party library, except of course at runtime, where it depends on the runtime of the platform.
yWorks owns the IP for all implementations in the core yFiles library. Some demos show the integration and make use of
third party software, but they are not required for other cases.
- Which papers and algorithms does yFiles implement?
The list of algorithms implemented by yFiles is long. For the common graph algorithms, we use the
traditional implementations with the standard optimizations. For many of the layout algorithms, ideas for the
implementation base on publicly available papers. Some algorithms (specifically the orthogonal layout and the balloon layout)
we created and helped with the creation of the algorithms and (co-)published the papers for the algorithms.
Most layout algorithms have been vastly modified, tuned, and enhanced, though, and don’t follow the original
implementation ideas, anymore. yWorks added useful features to these implementations to make the algorithms
work in less theoretical environments. We removed previously existing constraints of the original implementations
and added new ideas to make the algorithms useful for real-world usage. For most of these changes and improvements,
no papers have been published.
- Can I get the papers for the layout algorithms used in yFiles?
For some of the algorithms, you will find papers that describe the core idea of the layout algorithms.
For most algorithms, yWorks massively enhanced and modified the algorithms to support more advanced features that are
frequently required in real-world diagrams. For these modifications, we did not publish any papers. As a commercial
yFiles customer, you can obtain a license to the source code of yFiles where you can read, learn about, and modify
the algorithms in documented source code form, according to the license terms.
- Is a server required to host a graph drawing application?
yFiles for HTML does not require an active server component. As such, any server technology that can serve static HTML
pages and JavaScript will do. yFiles solely consists of a set of JavaScript files, a CSS file, and an HTML page to host
the visualization app. With caching enabled and properly configured, yFiles for HTML-powered apps can be a one-time
download and can run without an active internet connection, even directly from the file-system.
- Can I run yFiles for HTML graph drawing apps on the desktop?
With technologies like NW.js, Electron,
Visual Studio Code, and Webkit,
yFiles for HTML runs in native applications on the desktop and other devices.
The visualization engine requires an HTML-5 compliant browser engine with a working
DOM implementation and JavaScript support with at least ECMAScript 5. yFiles for HTML can run in a Node.js process and calculate layouts and run graph algorithms without a viewer component.
- Can yFiles for HTML powered graph apps run on the server?
The visualization engine requires an HTML-5 compliant browser engine with a working DOM implementation and JavaScript
support with at least ECMAScript 5. Technologies like Puppeteer and Webkit
provide these features on a headless server.
If no visualization is required, yFiles for HTML can run in a Node.js process and
calculate layouts and run graph algorithms without a visible view.
- What rendering technology does yFiles for HTML use for drawing graphs?
yFiles for HTML uses SVG, WebGL 1, WebGL 2, and HTML5 Canvas to draw graphs and diagrams. SVG, together with CSS styling,
animations, and transitions creates beautiful, high-fidelity diagram visualizations. WebGL can provide the performance to render even
the largest graphs. Combine all technologies and use them at the same time in the same diagram to get the best
possible user experience.
- Does yFiles support rendering graphs using WebGL?
WebGL is a modern, low-level rendering technology employed in modern browsers. yFiles supports using WebGL 1 and WebGL 2
for rendering large-scale, simple graph visualizations. yFiles comes with optimized built-in default visualizations that
use WebGL, but developers may use the full WebGL API to render contents into a yFiles diagram. yFiles supports
rendering SVG, Canvas, and WebGL in the same diagram. For medium-sized graphs, using SVG often is the preferred
choice due to simplicity, versatility, and performance. With the WebGL2 rendering backend the size of the graphs is
mostly limited by the performance of the graphics card adapter, only. Millions of elements can be rendered smoothly at the same
time on the screen in an animated fashion, even with lower-end dedicated graphics card adapters.
- Does yFiles use HTML5 Canvas for rendering graphs?
Canvas is a low-level rendering technology employed by most of today’s browsers.
yFiles supports using Canvas for rendering large-scale, simple graph visualizations, and for rendering bitmap
effects in the visualization. yFiles’ default styles usually use SVG or WebGL, but developers may use the full
Canvas API to render contents into a yFiles diagram. yFiles supports renderings with all three technologies at the
same time in the same diagram. For medium-sized graphs, using SVG often is the preferred choice due to simplicity,
versatility, and performance.
- Is yFiles using SVG for rendering graphs?
For medium-sized graphs, using SVG often is the preferred choice due to simplicity, versatility, and performance.
But yFiles supports renderings with SVG, HTML5 Canvas, and WebGL at the same time in the same diagram. SVG creates
high-fidelity vector graphics that work great for medium-sized diagrams and support CSS styling, animations,
and transitions, as well as perfect text rendering on all supported browsers.
- Can I create my diagramming app using TypeScript?
The API of yFiles for HTML has been designed carefully to work perfectly in a TypeScript
environment.
A complete TypeScript type definition file makes use of advanced TypeScript features such as nullability,
interfaces, enumerations, generics, subclassing, union types, overloads, asynchronous programming, and more.
yFiles for HTML is also available as an npm module, which makes the
inclusion of the library in any modern project a breeze.
- Can I use CSS for styling and animating my graphs?
One of the three main rendering technologies used by yFiles is SVG. SVG works on the DOM level and can be conveniently
styled and animated using CSS3 transitions and animations. Native CSS transitions and animations don’t block the main
thread and work smoothly even on slower devices on modern browsers. As such, they can outperform Canvas- and WebGL-based
solutions.
- Is yFiles available as a node module on npm?
yFiles does not have any third party dependencies and at its core only consists of several JavaScript files and a
CSS file. The package contains a package.json
file that can be used with the npm pack
command to create a
npm package of yFiles.
Licensees may put this npm package into private npm registries or file repositories for convenient installation using
npm or yarn.
yFiles for HTML is not currently available for the public on npmjs.org.
- Is the source code available for yFiles for HTML?
The sources for yFiles for HTML come in a minified, optimized form. Licensees have the option to get a
non-minified debugging variant of yFiles for HTML. There is also the option to get the complete sources of
yFiles for HTML with the right to modify and distribute derived versions of the library with custom applications.
- Can I use GWT to create my graph application?
yFiles for HTML is a native JavaScript library for which complete GWT bindings exist.
This enables GWT developers
to author high-quality graph visualization web applications using the Java programming language. The GWT bindings for
yFiles for HTML support various customizations. Developers may create custom subclasses of library classes and implement
interfaces as well as use the complete API to author their graph applications.
- Can I print my graphs from my web application?
yFiles for HTML provides mechanics to print your graphs.
With SVG styles, you get high-quality print-outs.
You can use poster printing and add custom headers, footers, and other content to print documents.
There is no active server component required for operation.
- Can I export my graphs as images from my web application?
yFiles for HTML provides several options for exporting
your graphs from your web applications.
The native export consists of an SVG export with high fidelity vector graphics when using SVG styles.
HTML5 Canvas-based styles and WebGL-based styles are included as bitmap images inside the SVG.
The resulting SVG contains all visuals and can be exported as is, to bitmap files (PNG), and PDF files
(with the free svg2pdf.js third party plugin).
- Can I export my graphs in other formats?
The native format for file import and export in yFiles for HTML is GraphML, which preserves the graph structure,
stylistic information, and custom business data. As a lighter-weight format, JSON is often preferred if some of the
data can be easily re-computed or isn’t necessary to be serialized. yFiles for HTML also has a separate companion
product that adds export capability to
Microsoft Visio®'s .vsdx file format,
while preserving full graphical fidelity as well as editability of the graph.
- Does yFiles support creating web applications for iOS and Android?
yFiles for HTML is a pure JavaScript library that leverages SVG, Canvas, WebGL, and ECMAScript 5+.
It runs on any major HTML5 compliant browser released since Internet Explorer 9.
This, of course, includes the native iOS and Android browsers.
Also, yFiles for HTML has built-in support for touch and pen input and does not require a mouse or connected physical
keyboard.
- Can I use React to create my graph application?
yFiles for HTML is framework agnostic and does not have any third party dependencies.
It integrates well with all major UI frameworks and has been specifically tested and prepared to work well with
React and its related frameworks.
You can use the npm module variant of yFiles for HTML to build modern React components and applications, using both
JavaScript and TypeScript. You can even use React components to render your SVG node templates.
- Can I use Vue.js to create my graph application?
yFiles for HTML is framework agnostic and does not have any third party dependencies.
It integrates well with all major UI frameworks and has been specifically tested and prepared to work well with
Vue.js.
You can use the npm module variant of yFiles for HTML to build modern Vue.js components and applications, using both
JavaScript and TypeScript. You can even use Vue.js components to render your SVG node templates.
- Can I use Angular to create my graph application?
yFiles for HTML is framework agnostic and does not have any third party dependencies.
It integrates well with all major UI frameworks and has been specifically tested and prepared to work well with
Angular and the Angular CLI.
You can use the npm module variant of yFiles for HTML to build modern Angular components and applications, using both
JavaScript and TypeScript. You can even use Angular components to render your SVG node templates.
- Can I use my UI framework to create my graph application?
yFiles for HTML is framework agnostic and does not have any third party dependencies.
It integrates well with all major UI frameworks and has been specifically designed to not conflict with well-behaved
third party UI frameworks.
The npm module variant of yFiles for HTML can be used like other npm packages to build modern components and
applications, using both JavaScript and TypeScript.
If your UI framework provides the ability to specify some CSS rules, to run JavaScript, and access to insert or upgrade
a DOM div element, it should be no problem to embed the yFiles graph component.
Please contact our technical support team should you run into any issues.
- Does yFiles use D3.js for rendering graphs?
No. yFiles for HTML uses its own rendering technology that supports both SVG, HTML5 Canvas, and WebGL at the same time.
The rendering engine uses virtualization to be able to deal with larger visualizations, too.
Developers can use D3.js to augment the visualization in yFiles for HTML, e.g., to render bar charts
inside node visualizations or to map scalar values to colors in the visualization.
- Can I use data binding for rendering my graphs?
Yes. yFiles supports data binding on different levels.
Developers can use data binding to bind the visualization for nodes, edges, ports, and labels to properties in the
underlying business data.
Reactive templating and binding libraries like Angular, React,
Vue.js, Svelte, or D3.js can be used for the rendering. yFiles also
comes with a simple, built-in, third-party-code-free templating engine for the visualization of graph items.
Binding the structure of the graph to reactive business data is also possible.
- Is there a low-code version of yFiles for me to get started?
Yes! If you are new to yFiles, the App Generator can help you create and scaffold your first yFiles-powered
app withing just minutes. You can interactively configure your data-sources, choose you UI-framework and programming language,
and share your project ideas with your team and customers.
- Can I use JSON to load my graphs?
The yFiles for HTML programming API allows developers to create graphs from any data source they have access to.
There are utility classes that help in quickly parsing and converting both
simple and complex data structures into graph visualizations.
- How can I load my graphs from the server?
Any technology that is available in a user agent can be used for
loading graphs from the server.
This includes REST APIs, but also custom binary protocols that work over WebSockets, as well as XML, JSON, plain-text,
etc.
- Do I need server-side rendering to render my diagrams?
No. The visualization part of yFiles for HTML is an interactive JavaScript component that runs inside the browser on the
client.
As such, rendering the diagram on the server would not result in an interactive diagram, but rather a static image.
yFiles for HTML does not require an active server component, and the page that hosts the diagram component can be
rendered on the server with static server-side rendering techniques that create the complete DOM on the server.
yFiles for HTML still needs to be loaded on the client to provide interactive features like zooming,
scrolling, editing, and animating the diagram.