FAQ

yFiles is a product family of commercial software libraries (SDKs) that support visualizing, editing, and analyzing graphs and graph-like diagrams. It is not a ready-to-use application or graph editor. The yFiles SDKs are available for many platforms (web, Java, .NET), providing a component for graph visualization, graph editor features, and an extensive set of algorithms for automatic data arrangement and graph analysis. Software developers can use yFiles to display, edit, and analyze diagrams in their own applications.

Right now, yFiles supports HTML / JavaScript / TypeScript, Java (Swing), JavaFX, .NET (WinForms), and WPF.

Developers can use concise, rich, complete APIs to create fresh, new applications, and user-experiences that match your corporate identity and exactly fit your specific use-cases. yFiles enables white-label integrations into your applications, with royalty-free and perpetual licensing. Any application that works with or displays relational data in the form of graphs, diagrams, and networks can be built with the help of yFiles.

yFiles not only lets you create your own customized applications but integrates well with your existing solutions and dashboards on desktop, mobile, and on the web. There are versions of yFiles available for all major platforms and frameworks.

yFiles offers the most extensive graph layout, visualization, and analysis APIs available commercially. In total, there are around ten thousand public API members (classes, properties, methods, interfaces, enumerations). yFiles uses a clean, consistent, mostly object-oriented architecture that offers extensive customization options and reusability for existing functionalities. API components can be (re-)combined, extended, configured, reused, and modified to a very high degree. It is not mandatory to know the complete API, of course. Most applications only require a minimal subset of the full functionality, and the advanced functionality and APIs may only be required for implementing unique requirements.

yFiles helps developers quickly create highly sophisticated diagramming applications. The extensive API has been carefully designed and thoroughly documented. There are developers' guides, source code tutorials, and fully documented complete source code demo applications that help to realize even the most advanced features. Inline API documentation lookup for all major IDEs with hundreds of code snippets and linked related topics help in writing robust code, efficiently. Accelerate productivity with integration samples for numerous major third-party systems

No, yFiles is not free. The yFiles software components are a product family of commercial programming libraries. If you want to use yFiles in your application, you will need an appropriate yFiles license. To test any of the yFiles SDKs, we provide fully functional evaluation versions.

For all your questions around yFiles licensing, the yWorks sales team will be happy to help you.

yFiles enables white-label integration into your applications, with royalty-free and perpetual licensing. There are no third-party code dependencies. The license types mainly depend on the number of developers who will be working with the library and in how many applications yFiles will be used.
Please refer to the pricing information and software license agreements of the respective product for more details.

The yFiles libraries come with fully documented demo applications, detailed API documentation, and extensive developers' guides. Apart from that, yWorks also offers professional support services for your development teams. They can connect directly with more than a dozen core yFiles library developers to get answers to their programming questions. Optionally, if you don't have the time or necessary team, yWorks can help you with consultancy and project work to get you and your apps up running quickly.

There is no public roadmap for yFiles. yFiles usually gets a new major feature release about every 10 to 15 months, with bugfixes or minor maintenance releases in between as required. Typically there are between one and five bugfix releases for each major release, and previous releases get important bugfixes, too. yWorks tries very hard to keep the libraries and APIs backward compatible so that customers can update to the newest version of yFiles regularly with little to no effort and still benefit from performance improvements and new features.

With yFiles, you go beyond merely analyzing and viewing data. You can have interactive, deeply integrated apps that don't just let you consume data sources but also enable users to create from scratch, modify, and work with both existing and changing data. Integrate with third party services to automatically trigger actions and apply updates in real-time and publish changes to third party systems while the user works with the graph. It's up to you to decide what your app can do.

yFiles comes with the most extensive set of fully configurable, extensible automatic layout algorithms, that not merely render the elements on the screen but help users understand their data and the relationships just by looking at the diagrams. yFiles includes hierarchic, organic (force-directed), orthogonal, tree-like, radial, balloon-like, and special purpose layouts. yFiles also supports incremental, partial, and interactive layouts, as well as various edge routing and automatic label placement algorithms.

Layout algorithms support various settings and constraints and are fully customizable in code. They support different node sizes, nested groups, bundled edges, orthogonally and octilinear routed edges. These algorithms consider and automatically place node, edge, and port labels. Nodes may be partitioned and clustered, and different layout styles can be mixed in the same diagram.

yFiles lets you analyze your graphs, connected data, and networks both on the fly and interactively with a complete set of efficient graph algorithm implementations. Choose from a range of different centrality measure implementations, automatic clustering algorithms, network flow algorithms, reachability and connectivity algorithms, pathfinding variants, cycle, and dependency analysis algorithms. For the best user experience, use the results to drive the visualization, interactivity, and layout.

yFiles has the most flexible, extensible, and easy to use diagramming APIs that are available commercially. Every aspect of the functionality is customizable with options ranging from high-level configuration settings, down to low-level implementation overrides: data acquisition, import, graph creation, display, interaction, animation, layout, export, printing, and third party service connectivity.

The in-memory graph model lets you export all the information to any system and file format. There are built-in export options to various file and image formats, but as a developer, you can create your own glue code to connect to arbitrary data storage systems and third party services.

Theoretically, the only limiting factor for the number of graph elements is the size of the computer's memory. In practice, performance is also a limiting factor. For the vast majority of use-cases, yFiles delivers best-in-class performance out-of-the-box. For very large visualizations and data-sets, there are options available that let developers tune between features, running-time, and quality of the results. yFiles can deal with graphs of any size and is only bound by the memory available and the runtime complexity of the algorithms. Large graphs may require adjusting the default settings and performance depends on more than just the number of elements in the diagram, but also the structure of the graph, the algorithm and configuration, as well as platform and hardware capabilities.

For more than 20 years, yFiles has been the choice of customers across diverse industries worldwide, serving both individual developers and major corporations. Its versatile application spans academia, public services, governmental organizations, and the commercial sector. Explore our references for a glimpse, including renowned software corporations, though not all allow public listing. Beyond the software industry giants, yFiles caters to numerous companies, from non-traditional software entities to smaller enterprises without dedicated IT departments. At its core, yFiles is a universal diagramming component, adaptable to any business domain requiring efficient handling and display of connected data.

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 30 developers has been working on the implementation for the visualization and interaction and the compatibility with the diverse platforms yFiles accommodates. 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.

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.

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.

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.

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.

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 are based on publicly available papers. Some algorithms (specifically the orthogonal layout and the radial tree layout (formerly 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.

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.

You can easily try yFiles in two ways.

1. yFiles Playground: Quickly and without registration, you can test yFiles in the yFiles sandbox, an online interactive development environment. This platform allows you to explore various features of yFiles, run example code, and experiment with creating and manipulating graphs directly in your browser.
2. Free Evaluation: For a more comprehensive experience, you can sign up for a free evaluation version of yFiles. This evaluation provides you with the full version of yFiles, allowing you to develop your prototype and access over 300 source code demos, along with comprehensive support from the yWorks team.

Yes, yWorks offers a free evaluation version of yFiles. During this trial period, you have access to all the features of the library, comprehensive support, and over 300 source code demos. This allows you to fully explore yFiles' capabilities and develop your prototype without any commitment.
Try yFiles.

The yFiles Playground is an interactive environment where you can explore yFiles capabilities directly in your browser. It allows you to try out various yFiles features, run example code, and share your own code snippets. This is an excellent way to get hands-on experience with yFiles before diving into a full evaluation.

You can access the yFiles Playground through the yWorks website. No installation is required; you just need to have JavaScript enabled in your browser. The yFiles sandbox provides a variety of code samples and interactive demos that showcase different features of yFiles.

yWorks provides a wealth of resources to help you get started with yFiles, including:

• Extensive documentation
• A Developer’s Guide
• API references
• Interactive demos
• Getting started with yFiles - YouTube Playlist

Additionally, you can visit the Getting Started with yFiles for HTML page for a quick and smooth start with yFiles for HTML.

The yFiles evaluation versions run for 60 days. To extend the trial period, if you would need more time to finalize your evaluation, you can get an additional evaluation version.

Yes, you can get an additional evaluation version from your account in the Customer Center.

Of course! The developers of your team can sign up to the yFiles Customer Center and get each their yFiles evaluation version.

Yes, we also provide implementation services around the yFiles libraries. Kindly get in touch with our sales team for more information.

Yes, it is. You can start your free yFiles trial here.

After the trial period has ended the yFiles-based diagramming functionality in your prototype will cease to work. If you want the diagramming functionality to continue to run following the trial period, a regular yFiles license will be needed. For all your questions around yFiles licensing, sales team will be happy to help you.

yWorks offers several license types for the yFiles SDKs, see the yFiles pricing page for more information. For a license type recommendation along your requirements, kindly see this service on the yWorks website.

Absolutely! yFiles neither stores nor transmits your data to any third party, including yWorks. You always have full control over where your data is stored or processed.

yWorks takes software security very seriously. Security incidents in our software are treated with the highest priority, and we are proud to report that there have been no security issues in the library. The structure and purpose of yFiles preclude most kinds of attacks. Specifically, yFiles does not use or interact with functionalities like cryptographic APIs, credential storage, or other security-critical components. yFiles itself also doesn't access the network or any data storage.

As a customer, you can use any of the yWorks' support channels to report a security incident with our library. For the fastest handling of the incident, we recommend using the customer support center to report the issue.

yFiles itself does not handle data encryption, as it is a third-party-free SDK. Developers have full control over how they implement data encryption within their applications using yFiles.

yFiles does not include specific built-in security features for web vulnerabilities as it is a third-party-free SDK. Developers have full control over implementing security measures such as preventing XSS or CSRF.

As a third-party-free SDK, yFiles gives developers the flexibility to implement features that ensure compliance with GDPR or other data protection regulations. yFiles ensures that your data remains where it belongs and is not sent to any cloud service or third party. For example, with yFiles for HTML, all calculations are performed exclusively in the browser, ensuring that your data stays within your control at all times.

Yes, the Balloon Layout is still available in yFiles. However, with the release of yFiles for HTML version 3.x, it has been renamed to Radial Tree Layout. Other yFiles products will gradually adopt this new name.

Yes, the Cactus Group Layout is still available in yFiles. With the release of yFiles for HTML version 3.x, it has been renamed to Radial Group Layout. Other yFiles products will gradually adopt this new name as well.

Yes, yFiles includes a Radial Tree Layout. This layout was previously known as Balloon Layout and was renamed with the release of yFiles for HTML version 3.x. Other yFiles products will gradually adopt this new name as well.

Yes, yFiles offers a Radial Group Layout. This layout was previously known as Cactus Group Layout and was newly named with the release of yFiles for HTML version 3.x. Other yFiles products will gradually adopt this new name as well.

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.

With technologies like NW.js, Electron, Visual Studio Code, and Webkit, yFiles for HTML runs in native applications on the desktop and on 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.

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 under the hood.

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 create 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.

WebGL is a modern, low-level rendering technology employed in modern browsers. yFiles extends its support to both 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.

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.

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.

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. Adding the library to any modern project is effortless, thanks to these capabilities.

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 less powerful devices running contemporary browsers. As such, they can outperform Canvas- and WebGL-based solutions.

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.

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.

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.

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.

yFiles for HTML provides several options for {yfiles-features-url}#image-export[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).

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.

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.

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.

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.

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.

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.

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.

Yes. yFiles for HTML 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.

Yes! If you are new to yFiles, the App Generator can help you create and scaffold your first yFiles-powered app within 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.

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.

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.

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.

To get started with yFiles for HTML, you'll need Node.js installed on your system. You can use the yFiles Dev Suite for an easy setup and follow the step-by-step guides in the Developer's Guide for detailed instructions.

After setting up Node.js, you can run the demos using the included dev server. Navigate to the yFiles-for-HTML-Complete directory and execute the start_demos script for your operating system.

Yes, yFiles can be integrated into existing JavaScript or TypeScript projects. The library is compatible with all modern web application frameworks, and there are specific integration guides and demos available for frameworks like React, Angular, and Vue.js.

The yFiles React Process Mining Component stands out for its seamless integration with React applications and its powerful graph visualization capabilities. Unlike standalone process mining tools, it leverages the yFiles SDK, a commercial programming library explicitly designed for graph, network, and diagram visualization. This integration enables developers to create highly customizable and interactive process mining diagrams within their React applications, offering unparalleled flexibility and functionality.

The yFiles React Process Mining Component excels in handling complex process mining tasks due to its sophisticated layout algorithms, advanced user input handling, and extensive customization options. Its built-in user input handling makes graph visualization highly interactive, while its flexible style options allow for tailored representation of process flows to suit any domain. Additionally, its layout algorithms enable the creation of clear, stunning, and complex graph visualizations, making it ideal for analyzing intricate process flows and identifying optimization opportunities.

Yes, the yFiles React Process Mining Component is capable of handling large-scale event logs with ease. Leveraging the power of the yFiles SDK, it provides efficient data processing and visualization capabilities, enabling smooth rendering and analysis of event logs containing thousands or even millions of data points. Its scalable architecture ensures optimal performance, even when dealing with extensive event data, making it suitable for enterprise-level process mining tasks.

The yFiles React Process Mining Component offers extensive customization and extensibility options, allowing developers to tailor the visualization and functionality to their specific requirements. With its built-in components and styling options, users can customize every aspect of the process mining diagrams, from node and edge styles to tooltips and user interactions. Furthermore, developers can extend the component's functionality by integrating additional yFiles features or building custom components, ensuring flexibility and adaptability to diverse use cases and workflows.

The yFiles React Process Mining Component empowers decision-makers with actionable insights derived from process data analysis. By visualizing process flows, identifying patterns, and detecting inefficiencies, it enables informed decision-making, leading to better resource allocation, improved performance, and strategic business outcomes.

To integrate the component, download the trial version of yFiles for HTML, install the Process Mining Component via npm, ensure necessary dependencies, and add the component to your application. Refer to the documentation for detailed steps.

To integrate the component, download the trial version of yFiles for HTML, install the Organization Chart component via npm, ensure necessary dependencies, and add the component to your application. Refer to the documentation for detailed steps.

The yFiles component is versatile and can be customized for various industries. Examples include corporations, healthcare organizations, educational institutions, and more.

Techniques such as level of detail rendering, collapsing substructures, and customization based on zoom levels are employed to improve readability and manage large organizational diagrams effectively.

Techniques such as level of detail rendering, collapsing substructures, and customization based on zoom levels are employed to improve readability and manage large organizational diagrams effectively.

Absolutely. The yFiles component allows a high level of customization. You can utilize custom React components to tailor the rendering of items based on specific requirements.

Notable features include sophisticated layout algorithms, interactive elements like popups and tooltips, customization of connection visualizations, and event notifications for state changes.

The content suggests techniques such as level of detail rendering, filtering out irrelevant data, and collapsing substructures to enhance rendering performance for large organizational diagrams.

Yes, the yFiles React Organization Chart Component offers elements like an overview for a simplified view of the entire graph and controls featuring a toolbar with buttons to adjust the viewport, providing an enriched user experience.

Certainly. The content suggests exploring industry-specific use cases, showcasing the adaptability of the yFiles component for diverse applications in finance, healthcare, tech, and more.

In addition to the yFiles React Organization Chart Component playground examples, the GitHub repository contains the sources of various example applications.

The yFiles component provides a highly adaptable solution by allowing the utilization of custom React components for rendering, offering extensive customization choices for both functionality and visual presentation.

yFiles React Components are a collection of UI components specifically designed to integrate the yFiles graph visualization library with React applications, enabling developers to create interactive and visually appealing graph-based user interfaces.

To get started, you need to install the yFiles for HTML library and choose a yFiles React component to install from npm. Detailed installation and setup instructions are provided on the documentation page of the specific React component.

You should have a working knowledge of React and basic JavaScript/TypeScript. The yFiles React Components require the yFiles for HTML library.

You can integrate a yFiles React Component by installing yFiles for HTML and the chosen React component, importing the component, and using it within your React application's component tree. The components are designed to be easily embedded and customized within your existing React components. Detailed installation and setup instructions are provided on the documentation page of the specific React component.

Yes, the exported VSDX files are fully compatible with Microsoft Visio and can be edited afterwards. It is possible to remove, add or change diagram items or contained business data. It is also possible to process the exported VSDX files with compliant tools, so you can use your existing Visio toolchain.

Yes, it is possible to add multiple yFiles graphs to a single VSDX file. You can have multiple diagrams on one page or have them distributed over several pages.

Yes, the VSDX Export can read and modify existing VSDX files and add one or multiple yFiles diagram(s).

For an easy implementation of an organization chart (also known as org chart, organizational chart, or hierarchy chart) in HTML, you can use yFiles for HTML. yFiles for HTML is a powerful library by yWorks designed specifically for graph and network visualization, offering advanced features for visualizing and managing hierarchical structures. Additionally, you can use the yFiles React Organization Chart Component for a seamless integration into your React application.

For an easy implementation of supply chain visualization (also known as supply network, supply chain management, or logistics network) in HTML, you can use yFiles for HTML. yFiles for HTML is a powerful library by yWorks designed specifically for graph and network visualization. It offers advanced features for visualizing and analyzing supply chains, including use cases such as inventory tracking, supplier relationship management, and logistics optimization. Additionally, you can use the yFiles React Supply Chain Component for a seamless integration into your React application.

For a straightforward implementation of company ownership visualization (also known as corporate ownership, equity structure, or shareholder mapping) in HTML, you can use yFiles for HTML. yFiles for HTML is a powerful library by yWorks designed specifically for graph and network visualization. It offers advanced features for visualizing and analyzing company ownership structures, including use cases such as identifying major shareholders, mapping equity relationships, and analyzing corporate hierarchies. Additionally, you can use the yFiles React Company Ownership Component for a seamless integration into your React application.

To integrate the component, download the trial version of yFiles for HTML, install the Company Ownership component via npm, ensure necessary dependencies, and add the component to your application. Refer to the documentation for detailed steps.

The yFiles component is versatile and can be customized for various industries. Examples include banking, insurance, actuaries, corporations, and more.

Techniques such as level of detail rendering, collapsing substructures, and customization based on zoom levels are employed to improve readability and manage large ownership diagrams effectively.

Absolutely. The yFiles component allows a high level of customization. You can utilize custom React components to tailor the rendering of items based on specific requirements.

Notable features include sophisticated layout algorithms, interactive elements like popups and tooltips, customization of connection visualizations, and event notifications for state changes.

The content suggests techniques such as level of detail rendering, filtering out irrelevant data, and collapsing substructures to enhance rendering performance for large organizational diagrams.

Yes, the component offers elements like an Overview for a simplified view of the entire graph and Controls featuring a toolbar with buttons to adjust the viewport, providing an enriched user experience.

Certainly. The content suggests exploring industry-specific use cases, showcasing the adaptability of the yFiles component for diverse applications in finance, insurance, tech, and more.

In addition to the yFiles React Company Ownership Component playground examples, the GitHub repository contains the sources of various example applications.

The yFiles component provides a highly adaptable solution by allowing the utilization of custom React components for rendering, offering extensive customization choices for both functionality and visual presentation.

To integrate the component, download the trial version of yFiles for HTML, install the Supply Chain component via npm, ensure necessary dependencies, and add the component to your application. Refer to the documentation for detailed steps.

The yFiles React Supply Chain Component optimizes supply chain management by providing advanced visualization tools, data analysis capabilities, and customization options. It enables users to visualize complex supply chain structures, analyze data, and make informed decisions to improve efficiency and effectiveness.

The benefits of using the yFiles React Supply Chain Component include streamlined data representation, enhanced decision-making, cost reduction, improved collaboration, risk mitigation, optimization of supply chain performance, and support for sustainability initiatives.

The yFiles React Supply Chain Component optimizes supply chain management by providing advanced visualization tools, data analysis capabilities, and customization options. It enables users to visualize complex supply chain structures, analyze data, and make informed decisions to improve efficiency and effectiveness.

The benefits of using the yFiles React Supply Chain Component include streamlined data representation, enhanced decision-making, cost reduction, improved collaboration, risk mitigation, optimization of supply chain performance, and support for sustainability initiatives.

The yFiles React Supply Chain Component helps manage large supply chains by offering features such as grouping, folding, graph search, and scalability. It enables users to visualize and analyze large datasets, simplify complex structures, and optimize supply chain processes effectively.

Specific features of yFiles for supply chain management include custom node and connection visualization, grouping and folding, graph search algorithms, custom tooltips, graph overview, and context menu. These features support various SCM tasks such as route optimization, network analysis, inventory management, and supplier selection.

The yFiles React Supply Chain Component contributes to sustainability in supply chain management by enabling visualization and optimization of sustainable practices. It supports tracking carbon emissions, monitoring resource usage, visualizing sustainable sourcing networks, and promoting ethical sourcing practices.

Yes. A key goal in the design of yFiles for Java (Swing) was to provide a modernized API that covers the features of the Java 8 release: stream API, lambda expressions, and functional interfaces. We always ensure that yFiles works with the latest official releases of Java and that new language features integrate well with the design of the API.

No. To be compatible with Java 8, we decided not to publish yFiles for Java (Swing) as a module. However, you can use yFiles for Java (Swing) in your Java 9 (or higher) application, since JARs without module descriptors are used as automatic modules, which allows using pre-Java-9 libraries.

Yes. However, Java does not support SVG images out-of-the-box, so third party software is required. In a source code demo, we show how to visualize graph elements with SVG images with the help of a third party library.

Yes. With yFiles for Java (Swing), you can export your graphs into any image format that is provided by the current Java installation, e.g., JPEG, PNG, GIF, and BMP, without additional software. If you want to export to another format, you can easily use third-party libraries with yFiles for Java (Swing) in your application. For example, we provide source code demos that show you how to export graphs to PDF or to SVG using third-party libraries.

Yes. yFiles for Java (Swing) provides mechanics to print your diagrams. You can use poster printing and add custom headers, footers, and other content to print documents. There is no additional software component required for operation.

Yes. yFiles for Java (Swing) 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. Binding the structure of the graph to reactive business data is also possible.

Yes, you can use yFiles for Java (Swing) on headless environments like servers.

Although Swing components may be part of node, label, or port visualizations in yFiles for Java (Swing), this comes with several drawbacks. For one, performance suffers, as those styles are very costly to render, compared to "normal" yFiles for Java (Swing) item styles. Then there are some different Look & Feel implementations in Swing, and some of them make drawing components this way a bit harder. Components may become pixelated when zooming or not respecting zoom level at all; icons can go missing, etc. This is mainly because Swing components were usually not designed to be used in this way.

The Standard Widget Toolkit (SWT) provides support for embedding Swing components in SWT applications. However, the integration is rather poor. You need a lot of extra code to manage all the integration problems. There are third party libraries that encapsulate some of the workarounds. Unfortunately, these libraries are outdated and do not resolve all the weaknesses. We are not aware of any viable solution for embedding Swing content in an SWT application. For that reason, we strongly recommend using yFiles for JavaFX instead, which is much better suited for this purpose.

Yes. As Kotlin was designed with Java interoperability in mind, you can also use the library jar of yFiles for Java (Swing) in your Kotlin application. In order to support Kotlin's null-safety, a large part of the yFiles for JavaFX API is annotated with nullability annotations.

Yes. We support both Oracle's JDK and the OpenJDK. The library, the source code demos, and the tutorial steps have been extensively tested with both JDKs on Windows and Linux as well as on the Mac OS.

Building and running applications based on yFiles for Java (Swing) requires Java 8 or higher. We recommend using the latest OpenJDK for developing and the latest OpenJDK runtime for running applications. All those SDKs and runtimes are available free of charge for Microsoft Windows, Mac OS, Linux, and Solaris. If you need to support Java 7 and earlier, we recommend the 2.x line of yFiles for Java.

Yes. yFiles natively supports loading and saving diagrams using the standard diagram exchange format GraphML. All yFiles features like styles, grouping, and folding are supported. You are not limited to GraphML, though. You can easily and quickly build diagrams from any structured data source like CSV, JSON, XML, databases, and others. We provide a source code demo that shows how to load data from a Neo4j database and display it with yFiles for Java (Swing).

Yes. A key goal in the design of yFiles for JavaFX was to provide a modernized API that covers the features of Java 8: the stream API, lambda expressions, and functional interfaces. We always ensure that yFiles works with the latest official releases of Java and that new language features integrate well with the design of the API.

No. To be compatible with Java 8, we decided not to publish yFiles for JavaFX as a module. However, you can use yFiles for JavaFX in your Java 9 (or higher) application, since JARs without module descriptors are used as automatic modules, which allows using pre-Java 9 libraries.

Yes. Using CSS in JavaFX is similar to using CSS in HTML. The graphical elements in yFiles for JavaFX are JavaFX nodes that are associated with style classes. This makes it easy to control the look of your user interface using CSS styling. We also provide a source code demo that shows how to style the yFiles UI elements with CSS to match your color theme.

Yes. With yFiles for JavaFX, you can export your graphs into any image format that is provided by the current Java installation, e.g., JPEG, PNG, GIF, and BMP, without additional software. If you want to export to another format, you can easily use third-party libraries with yFiles for JavaFX in your application. For example, we provide source code demos that show you how to export graphs to SVG using third-party libraries.

Yes. yFiles for JavaFX provides mechanics to print your diagrams. You can use poster printing and add custom headers, footers, and other content to print documents. There is no additional software component required for operation.

Yes. You can use the GUI controls of yFiles for JavaFX in the Scene Builder to quickly design the user interface of your application. Our developer's guide explains step by step how to import the yFiles controls into the Scene Builder, to drag and drop them from the controls palette onto the Scene Builder's canvas like you would add any other control.

Yes. JavaFX provides support for enriching an existing Eclipse/SWT application with JavaFX content. One of the most significant benefits of embedding JavaFX in the Standard Widget Toolkit (SWT) is that the UI threads of both toolkits are the same. This means there are no restrictions when calling methods defined in one toolkit from the other. Furthermore, the Eclipse e(fx)clipse project provides tooling and runtime components that help developers create RCP applications with JavaFX. We offer a simple source code demo that shows how to integrate yFiles for JavaFX in a SWT application. In addition, there is a very extensive source code demo that integrates yFiles for JavaFX in an Eclipse E4 RCP.

Yes. yFiles for JavaFX 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. yFiles for JavaFX also comes with a templating engine for the visualization of graph items that uses the JavaFX binding mechanisms. Binding the structure of the graph to reactive business data is also possible.

In case you want to use yFiles in a headless environment, we recommend using yFiles for Java (Swing). Unlike JavaFX, Swing is much better suited for this purpose.

Yes. yFiles for JavaFX has out-of-the-box support for integrating native JavaFX controls declared in FXML to draw graphs and diagrams. This enables you to separate your user interface code from the rest of your application code. And of course, you can style the JavaFX controls declared inside a FXML file with CSS. FXML also supports expression bindings, which allow you to automatically update the user interface as the underlying data of your application changes.

Yes. yFiles for JavaFX ships with an interaction mode that enables easy and intuitive diagram creations. These interactions are highly customizable and can be tailored to any specific domain. All those features work with touch as well as with a mouse. Customizable keyboard shortcuts also exist for many common operations.

Yes. As Kotlin was designed with Java interoperability in mind, you can also use the library jar of yFiles for JavaFX in your Kotlin application. In order to support Kotlin's null-safety, a large part of the yFiles for JavaFX API is annotated with nullability annotations.

Yes. We support both Oracle's JDK and the OpenJDK. The library, the demos, and tutorial steps have been extensively tested with both JDKs on Windows and Linux as well as on the Mac OS.

Building and running applications based on yFiles for JavaFX requires Java 8 or higher. We recommend using the latest OpenJDK and the latest JavaFX SDK for developing and the latest OpenJDK runtime and the latest JavaFX runtime for running applications. All those SDKs and runtimes are available free of charge for Microsoft Windows, Mac OS, Linux, and Solaris. If you need to support Java 7 and earlier, we recommend the 2.x line of yFiles for Java.

Yes. yFiles natively supports loading and saving diagrams using the standard diagram exchange format GraphML. All yFiles features like styles, grouping, and folding are supported. You are not limited to GraphML, though. You can easily and quickly build diagrams from any structured data source like CSV, JSON, XML, databases, and others. We provide a source code demo that shows how to load data from a Neo4j database and display it with yFiles for JavaFX.

Yes. yFiles.NET includes image export into standard raster image formats like PNG or JPEG. Vector images can be exported as EMF.

Yes. yFiles.NET includes printing support out of the box. You can use poster printing and add custom headers, footers, and other content to print documents.

Yes, yFiles.NET supports different options for data binding, and the bound data can influence the graph structure, the visual appearance of graph items, as well as automatic layouts.

Of course. The easiest way would be describing the relationship of your data in a declarative way with the GraphBuilder class. However, the whole process can be customized.

yFiles.NET runs on .NET Framework 4.0 and later. Using the parts of the API that require async/await is easier with .NET 4.5 and later. yFiles.NET also runs on .NET Core 3.0. The layout and analysis algorithms only require .NET Core 2.0.

yFiles.NET runs on .NET Core 3 or later, but only on Windows. The layout and graph analysis algorithms of yFiles.NET don't have a dependency on Windows Forms and run on .NET Core 2.0 and later on all supported platforms of .NET Core.

The viewer part of yFiles.NET might run with Mono's Windows Forms implementation. This is untested, however. The graph layout and analysis algorithms run on Mono, though.

The viewer part of yFiles.NET might run on Linux with Mono's Windows Forms implementation. This is untested, however. The graph layout and analysis algorithms run on Linux via either Mono or .NET Core.

The yFiles.NET package contains a set of batch files to create a private NuGet package of yFiles.NET. Licensees may put this NuGet package into a private NuGet repository for convenient installation using packages.config or <PackageReference/>. yFiles.NET is not currently available on the public NuGet gallery.

Yes, and those templates may also use bindings to business data associated with the graph elements to create part of the visualization.

Yes. yFiles WPF includes image export into standard raster image formats like PNG or JPEG. Vector images can be exported as XPS.

Yes. yFiles WPF includes printing support out of the box. You can use poster printing and add custom headers, footers, and other content to print documents.

Yes, yFiles WPF supports different options for data binding, and the bound data can influence the graph structure, the visual appearance of graph items, as well as automatic layouts. Native WPF bindings can be used to create graphs from data and for item visualization.

Yes. Anything you can use elsewhere in a WPF Window can be used for visualizing graph elements since yFiles WPF renders the graph as part of the WPF visual tree.

Of course. The easiest way would be describing the relationship of your data in a declarative way with the GraphSource class. However, the whole process can be customized.

yFiles WPF runs on .NET Framework 4.0 and later. Using the parts of the API that require async/await is easier with .NET 4.5 and later. yFiles WPF also runs on .NET Core 3.0. The layout and analysis algorithms only require .NET Core 2.0.

yFiles WPF runs on .NET Core 3 or later, but only on Windows. The layout and graph analysis algorithms of yFiles WPF don't have a dependency on WPF and run on .NET Core 2.0 and later on all supported platforms of .NET Core.

No. WPF is closely tied to Windows, and Mono does not support WPF. The graph layout and analysis algorithms run on Mono, though.

No. WPF is closely tied to Windows and thus not available on Linux. The graph layout and analysis algorithms run on Linux via either Mono or .NET Core.

The yFiles WPF package contains a set of batch files to create a private NuGet package of yFiles WPF. Licensees may put this NuGet package into a private NuGet repository for convenient installation using packages.config or <PackageReference/>. yFiles WPF is not currently available on the public NuGet gallery.

yFiles Graphs for Jupyter is a free extension designed for JupyterLab and Jupyter Notebook that enables diagram visualization.
It allows users to import structured data from various Python graph packages like NetworkX, igraph, PyGraphviz, or any structured list of nodes and edges, and visualize it using powerful layout algorithms.

yFiles Graphs for Jupyter can import structured data from popular Python graph packages like NetworkX, igraph, PyGraphviz, Neo4j, or any structured list of nodes and edges.

The extension includes powerful layout algorithms from the yFiles SDK, such as organic, hierarchic, tree, orthogonal, circular, and radial layouts, which users can easily apply to their graph structures.

By providing suitable and clear visualizations, yFiles Graphs for Jupyter helps users gain a better understanding of their data. Visualization aids in identifying patterns, relationships, and structures within the data.

The embedded extension provides interactive features such as automatic layouts, item neighborhood and data views, and search capabilities. These features enhance user interaction and exploration of the data.

Yes, users can customize visualizations using the provided Python API. They specify data-driven mappings for various aspects of the visualization, like item color, text labels, or geometry to tailor visualizations to their specific needs.

Yes, yFiles Graphs for Jupyter is designed to handle large datasets efficiently. Its high-performance algorithms and interactive features ensure smooth visualization and exploration even for complex and extensive datasets.

If you have more questions or need further information, you can find helpful resources at the following links:

• GitHub page: Browse the source code, report issues, and contribute to the project.
• Sample Notebooks: Explore example notebooks to see yFiles Graphs for Jupyter in action and learn from practical examples.
• Documentation: Access comprehensive documentation, including tutorials, API references, and usage guides.

You can install yFiles Graphs for Jupyter using pip. Run the following command in your Jupyter Notebook or command line:
pip install yfiles_jupyter_graphs

yFiles Graphs for Jupyter requires Python 3.6 or later and works with Jupyter Notebooks. It is compatible with all major operating systems, including Windows, macOS, and Linux.

You can use yFiles Graphs for Jupyter in many environments that support Jupyter notebooks, including but not limited to JupyterLab or Jupyter Notebook, Visual Studio Code, and Google Colaboratory.
Just try it in your preferred platform for Jupyter notebooks.

To create and visualize graphs using Python, developers can utilize yFiles Graphs for Jupyter.
This widget enables easy creation of interactive graphs directly within Jupyter Notebooks. With powerful visualization and automatic layouts, along with extensive customization options, it provides an ideal solution for Python developers and data scientists. The widget is compatible with various environments such as JupyterLab, Jupyter Notebook, Visual Studio Code, Google Colaboratory, and many more Jupyter environments.

To visualize graph data from a Pandas DataFrame in Python, you can use the yFiles Graphs for Jupyter library. The process involves importing your data into a DataFrame, creating nodes and edges from the DataFrame, customizing the graph layout, and displaying the diagram within a Jupyter notebook.
For a detailed guide and example code, you can refer to the "14_pandas_import.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

To visualize graph data from Neo4j in Python, you can use the yFiles Graphs for Jupyter widget. The process involves connecting to a Neo4j database, importing the graph data, creating nodes and edges, customizing the graph layout, and displaying the diagram within a Jupyter notebook.
For detailed instructions and example code, refer to the "16_neo4j_import.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

To visualize graph data from NetworkX in Python, you can use the yFiles Graphs for Jupyter plugin. The process covers importing your NetworkX graph, converting it to yFiles format, customizing the graph layout, and displaying it within a Jupyter notebook.
For detailed instructions and example code, refer to the "13_networkx_import.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

To visualize graph data from iGraph in Python, you can use the yFiles Graphs for Jupyter plugin. The process involves creating an iGraph graph, converting it to a yFiles graph, customizing the layout, and displaying it within a Jupyter notebook.
For a detailed guide and example code, refer to the "17_igraph_import.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

To visualize graph data using Graphviz in Python, you can utilize the yFiles Graphs for Jupyter library. This involves creating a graph using Graphviz, converting it to a yFiles graph, customizing the layout, and displaying the graph within a Jupyter notebook.
For detailed instructions and example code, please refer to the "15_graphviz_import.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

To visualize graph data using Graph-tool in Python, you can use the yFiles Graphs for Jupyter library. This involves creating a graph with Graph-tool, converting it to a yFiles graph, adjusting the layout, and displaying the graph within a Jupyter notebook.
Fora detailed guide and example code, refer to the "18_graph-tool_import.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

Yes, you can visualize graphs in Jupyter notebooks using the yFiles Graphs for Jupyter library. This tool allows you to create, customize, and display graph visualizations directly within a Jupyter notebook. For various examples and detailed guides on how to use this library, you can explore the yWorks/yfiles-jupyter-graphs GitHub repository.

Yes, you can use Leaflet maps for visualizing geographic data as graphs in Python with the yFiles Graphs for Jupyter library. This integration allows you to overlay coordinate data for graphs on Leaflet maps within a Jupyter notebook. For a detailed guide and example code, refer to the "30_leaflet_mapping.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

You can map labels to nodes and edges in a graph using the yFiles Graphs for Jupyter library. This involves defining label data and mapping it to graph elements for clear identification and better visualization. For a detailed guide and example code, refer to the "02_label_mapping.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

You can change the color of nodes and edges in a graph using the yFiles Graphs for Jupyter library. This involves setting up color mappings based on specific criteria to enhance the visual distinction between different graph elements. For detailed instructions and example code, refer to the "03_color_mapping.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

To adjust the size of nodes and edges in a graph, you can use the yFiles Graphs for Jupyter library. This involves defining size mappings to make certain nodes or edges more prominent based on specific attributes. For a detailed guide and example code, refer to the "05_size_mapping.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

You can position nodes and edges in a specific layout in a graph using the yFiles Graphs for Jupyter library. This involves applying various layout algorithms to organize graph elements for better readability and analysis. For detailed instructions and example code, refer to the "06_position_mapping.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

To create and visualize hierarchical graphs, you can use the yFiles Graphs for Jupyter library. This involves defining parent-child relationships between nodes and applying hierarchical layout algorithms. For a detailed guide and example code, refer to the "31_nested_graphs.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

Yes, you can map different properties to nodes in graphs using the yFiles Graphs for Jupyter widget. This feature allows you to assign visual attributes such as colors, sizes, labels, and styles to nodes based on data attributes, enhancing the clarity and information conveyed by your graph visualizations. For a detailed guide and example code, refer to the "07_property_mapping.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

You can map node styles based on data properties using the yFiles Graphs for Jupyter widget by defining style mappings that assign specific visual characteristics to nodes. This capability enables you to differentiate node categories or highlight important nodes within your graph visualizations. For a detailed guide and example code, refer to the "08_styles_mapping.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

Yes, it is possible to map node types to different visual representations using the yFiles Graphs for Jupyter widget. This feature allows you to assign unique visual attributes or behaviors to different node types based on data attributes, enhancing visual clarity and understanding of complex graph structures. For a detailed guide and example code, refer to the "09_type_mapping.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

Graphs can support edge direction mapping based on data properties using the yFiles Graphs for Jupyter widget by visualizing directional relationships between nodes. This feature helps represent flow or connections within graphs, improving the readability and analysis of directional graph data. For a detailed guide and example code, refer to the "10_direction_mapping.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

Yes, you can adjust edge thickness based on data attributes using the yFiles Graphs for Jupyter widget with edge thickness factor mapping. This functionality allows you to emphasize the strength or significance of connections between nodes in your graph visualizations. For a detailed guide and example code, refer to the "02_label_mapping.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

Yes, you can visualize nested graphs using the yFiles Graphs for Jupyter library. This feature allows you to represent hierarchical structures or complex relationships within graphs, supporting in-depth analysis and exploration directly in your Jupyter notebook environment. For a detailed guide and example code, refer to the "31_nested_graphs.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

Visualizing large graphs in Python is achievable using the yFiles Graphs for Jupyter library. This library provides efficient rendering and interaction capabilities suitable for handling complex and extensive graph data directly within your Jupyter environment. For a detailed guide and example code, refer to the "20_large-diagram.ipynb" notebook in the yWorks/yfiles-jupyter-graphs GitHub repository.

Process mining is a data-driven technique used to analyze event logs from various systems to understand, visualize, and improve business processes. By extracting insights from event data, process mining reveals the actual flow of processes, identifies bottlenecks, deviations, and opportunities for improvement.

Process mining works by analyzing event logs, containing data about each step or activity in a process, including timestamps, durations, and outcomes. Using specialized algorithms, process mining software transforms this raw data into visual representations of process flows, enabling stakeholders to identify patterns, inefficiencies, and areas for improvement.

Process mining offers several benefits, including:

• Enhanced process transparency and visibility
• Identification of bottlenecks and inefficiencies
• Improved compliance and governance
• Data-driven decision-making
• Continuous process improvement
• Automation opportunities
• Increased operational efficiency and effectiveness

yFiles enhances LlamaIndex by providing interactive and customizable graph visualizations that help:

• Reveal hidden patterns in document and entity relationships.
• Improve debugging by visually analyzing query responses.
• Optimize knowledge retrieval pipelines through better data structuring.
• Increase transparency in how LLMs process and link information.

yFiles enhances Create Llama by providing interactive and customizable graph visualizations for:

• Understanding document relationships in knowledge retrieval.
• Debugging LLM pipelines through structured graph views.
• Optimizing RAG workflows with intuitive data exploration tools.
• Detecting biases and anomalies within LLM-generated knowledge graphs.

Yes! yFiles is designed for scalability and performance, making it an excellent choice for large-scale AI applications like Create Llama. Its powerful graph layouts, real-time updates, and customization options allow developers to manage complex LLM workflows efficiently, regardless of data size or structure.

LlamaIndex is a data framework that connects LLMs with external knowledge sources, enabling better retrieval-augmented generation (RAG) and structured data processing. However, understanding how documents and concepts interconnect can be challenging. By using yFiles for graph visualization, developers can explore these relationships interactively, making it easier to optimize query performance, detect biases, and refine data connections.

Create Llama is a framework designed to streamline the development and management of LLM-powered applications. It often involves handling complex data structures, such as knowledge graphs, which can be effectively visualized using yFiles. By integrating yFiles with Create Llama, developers can gain deeper insights into AI model behavior, data relationships, and retrieval-augmented generation (RAG) processes.

Business Process Model and Notation (BPMN) is a standardized method for representing business processes visually. It facilitates clear communication between technical and business stakeholders, aiding in workflow optimization and efficiency improvement.

yFiles offers robust tools for creating interactive BPMN diagrams with automatic layout algorithms. It supports rich visualizations and intuitive interactions, ensuring clear and engaging representations of complex business processes.

Yes, yFiles is designed to integrate seamlessly with various Business Process Management (BPM) systems, allowing for efficient incorporation of BPMN diagram visualizations into your current workflows.

Absolutely! yFiles fully supports BPMN 2.0 elements and provides the flexibility to customize diagrams according to industry-specific requirements. Developers can tailor visual representations, apply custom styling, and integrate BPMN notation rules to ensure compliance with business process management standards. This makes yFiles an excellent choice for organizations that need reliable BPMN visualization with high adaptability.

Integrating yFiles into a BPMN-based application is straightforward, thanks to its comprehensive API and rich documentation. Developers can use yFiles to load BPMN data, apply advanced layouts, and enable interactive editing features. With built-in support for web technologies, Java, and .NET, yFiles seamlessly integrates into various environments, allowing businesses to enhance their BPMN workflow visualization with ease.

Yes, the exported VSDX files are compatible with Visio 2013 and later versions.

To use the plugin, simply integrate it into your yFiles application and call the export functions as described in the Developer's Guide and the API Documentation.
You can find a detailed tutorial in the video linked here.

While most features are supported, certain complex styles and custom visualizations might not be fully represented in the VSDX format due to differences between yFiles and Visio's rendering capabilities.

Yes, annotations and metadata can be exported, but some custom properties might require additional handling depending on how they are implemented in your diagrams.

VSDX Export is a paid add-on for the commercial yFiles for HTML software component that allows you to export yFiles diagrams to VSDX format, compatible with Microsoft Visio®. This add-on facilitates sharing, viewing, and editing of diagrams using any VSDX viewer.

For more information on licensing this add-on, kindly get in touch with the yWorks sales team.

Yes, the export process is highly customizable to meet complex requirements, although typical use cases work out of the box.

VSDX Export for yFiles for HTML can load VSSX stencil files and use their masters and style sheets as templates for the exported shapes in the VSDX file. This allows for consistent styling and shape usage across your diagrams, ensuring they match your desired Visio templates and standards.

Yes, highly discounted licenses for academic and research purposes are available for yFiles. For more information, please contact the yWorks sales team at sales@yworks.com.

yWorks is committed to supporting startup and nonprofit projects. Please email sales@yworks.com with details about your project, and the team will do their best to assist you.

The use case demo applications available on www.yfiles.com/demos illustrate how specific scenarios can be implemented using the yFiles for HTML SDK. These demos include various use cases such as:

• Organization chart
• BPMN editor
• Graph analysis
• Flowchart editor
• Supply chain
• Process mining
• Company ownership chart
• Fraud detection
• ... and many more.

While these demo applications are not standalone products available for direct purchase, the entire source code for nearly all of them is included as part of the yFiles for HTML SDK. This means that if one of these demos matches your use case, you can use the provided source code as a starting point to develop your own customized solution. With the yFiles for HTML SDK, you can easily adapt the demos to create high-class, tailor-made applications that fit your specific requirements.

To see the source code in action or for a sneak peek, you can explore the yFiles demos directly in the yWorks GitHub repository. Additionally, to test the full capabilities of the yFiles for HTML SDK, sign up in the yWorks Customer Center and download a 60-day fully functional evaluation version, which includes access to all demo apps with their complete source code.

For more information on acquiring a yFiles for HTML license or to discuss your specific requirements, please reach out to the yWorks sales team at sales@yworks.com. The team will be happy to assist with any licensing questions you may have.

ChatGPT interprets natural language prompts and is instructed to either create a structured JSON graph response or to generate a code snippet that is executed on the existing graph. This response is then processed by yEd Live to create or change the graph accordingly.

Simply load your graph, click the "AI assisted prompts" button in the bottom right of the canvas, review and agree to the terms, and start editing your graph using natural language prompts.

The goal is to implement an intelligent assistant that allows users to generate and edit diagrams using natural language descriptions. This integration aims to provide support for graph editing, styling, and arranging through user-friendly language commands.

ChatGPT in yEd Live supports the creation of various diagrams, including flowcharts, network diagrams, organizational charts, and more. Users can describe their desired diagrams using natural language prompts.

yEd Live operates entirely on your local machine, ensuring that your data stays with you. At no point are your diagrams, designs, or any other diagram data sent to our servers or any third party. You can create and edit diagrams with full confidence that your sensitive information remains secure and private.

Users can provide feedback, suggestions, or make inquiries through the "Feedback" page in yEd Live's menu.

No, yEd Live does not transmit any data to third parties. Your data remains on your local machine. Data only leaves your client when you explicitly use one of the integrated cloud storage services or the AI support, in which case the necessary data is securely transferred to the service of your choice.

"Generate Graph" always creates a new graph and returns a JSON response. "Edit Graph" creates a code snippet with edit instructions that is executed on the diagram.

Yes, yEd Live is designed to be compliant with GDPR and other data protection regulations. Since yEd Live operates locally on your machine and does not send data to external servers, your data remains within your control, helping you to maintain compliance with data protection laws.