Have something to say?
Linux Support
User problem Many potential users of Plotly Studio are operating on Linux hardware. Plotly Studio currently lacks support for these systems, preventing these users from utilizing the software. What is it? This is a proposed enhancement to Plotly Studio to introduce compatibility with Linux-based systems. It involves developing and testing specific versions or configurations of Plotly Studio that can run effectively on Linux computers. What does it allow users to do? This feature would allow users with Linux hardware to install, launch, and fully utilize Plotly Studio. It would enable them to leverage all of Plotly Studio's functionalities, including data import, AI-driven app generation, visualization, and deployment, without requiring a VM or using another computer. This ensures that a broader segment of our user base can access and benefit from Plotly Studio.
Data Sources
This feature introduces native data connectors in Plotly Studio, enabling users to directly and securely link to popular cloud data warehouses and lakehouses like Snowflake and Databricks. This allows users to browse and select tables, execute SQL queries, import results for visualizations and applications, and build continuously updated data applications within Plotly Studio, overcoming current limitations with dynamic data sources.
Save and Import Prompts
User problem Users currently lack a streamlined way to save and reuse specific prompts or configurations within Plotly Studio, making it challenging to replicate or build upon previously successful generations of charts, components, or entire applications. This can lead to inefficiencies and inconsistencies when trying to achieve specific design or functional outcomes. What is it? This feature introduces prompt saving and importing capabilities within Plotly Studio, applicable to individual charts, components, and the overall application. It's essentially a way for users to create a library of successful configurations and creative starting points. What does it allow users to do? This feature allows users to: Save outlines of applications they've generated, ensuring safe keeping and easy retrieval for later use or modification. Generate new applications, charts, or components using the exact, pre-defined prompt templates they've saved previously. Tweak and modify saved prompt templates as needed to adapt to new requirements, experiment with variations, or iterate quickly on a base design.
Intel-based Mac Support
User Problem Many users of Plotly Studio are operating on older Mac hardware equipped with Intel chips. Plotly Studio currently lacks support for these systems, preventing these users from utilizing the software. While Apple has ceased manufacturing Intel-based Macs, a significant number of our users may still be relying on this hardware, hindering their ability to adopt or continue using Plotly Studio until they upgrade their systems. What is it? This is a proposed enhancement to Plotly Studio to introduce compatibility with Intel-based Mac systems. It involves developing and testing specific versions or configurations of Plotly Studio that can run effectively on Apple computers powered by Intel processors. This addresses the existing gap in hardware support, allowing the software to function natively on a wider range of Mac devices. What Does it Allow Users to Do? This feature would allow users with Intel-based Mac hardware to install, launch, and fully utilize Plotly Studio. It would enable them to leverage all of Plotly Studio's functionalities. Users would be able to access and benefit from Plotly Studio without requiring an upgrade to newer Apple Silicon-based hardware. This ensures that a broader segment of the user base can access the software, regardless of their Mac's processor architecture.
Scheduled Data Refresh & Caching
User Problem Users building data-driven applications in Plotly Studio currently have no way to trigger data updates, relying on hacky workarounds and re-publishing apps manually. This can lead to apps displaying stale data, requiring constant manual intervention, and hindering the ability to present timely and accurate insights to viewers. What is it? This is a new capability within Plotly Studio that introduces Scheduled Data Refreshes and Caching Rules for applications. It provides a robust, back-end mechanism to define how and when the underlying data extracts for an app are updated. What Does it Allow Users to Do? This feature allows users to: Automate Data Updates: Users can define a specific, recurring schedule for their application's data extracts to be pulled and refreshed automatically. This ensures their apps consistently display the most up-to-date information without manual effort. Customize Refresh Frequency: Users can set the refresh interval using through the Data Sources chat with natural language. This will be interpreted and applied as a crontab expression used in the @schedule decorator in the data source code. Set Caching Rules: Users can choose from distinct data refresh/caching behaviors to optimize performance and data freshness: Never: The data remains static. On-demand: The data refreshes every time the application is loaded. Scheduled: The data refreshes based on the user-defined frequency.
Theme Designer UI
User problem The current LLM-based theme generation in Plotly Studio is excellent for creating broad, high-level changes. However, it lacks the precision users need for making specific, granular adjustments. Users require a more direct and precise way to modify individual elements of their themes, such as colors, fonts, and spacing, without using generative AI. They need a tool that allows for surgical edits while providing a live preview of how these changes affect all visual components of their application. What is it? The Plotly Studio Theme Designer is a new user interface (UI) designed specifically for creating and editing application themes. It provides a visual, point-and-click environment for theme customization, offering direct control over a theme's properties. Unlike the generative AI workflow, this tool provides a structured approach to theme management, allowing for precise modifications to any design element. What does it allow users to do? ✨ The Theme Designer allows users to: Make surgical edits to a theme's colors, fonts, and spacing. Use simple form controls (like color pickers, dropdowns, and sliders) to adjust theme properties easily. See a live preview of how their theme changes will be applied to all UI elements, including charts, buttons, and text, ensuring a cohesive design before saving.
Replicate Project
User problem Users need a way to safeguard their work in Plotly Studio, particularly after successfully generating an app. Without a "save point" or replication feature, making subsequent edits carries the risk of irrevocably altering or even losing the functional state of their application. This lack of a robust versioning mechanism can lead to significant frustration and inefficiency, as users cannot freely experiment with changes or revert to a previously working version. What is it? This feature introduces the ability to create copies of an existing Plotly Studio project. This "project replication" essentially generates a duplicate of the entire project, including all associated files, configurations, and generated application code, at a specific point in time. What does it allow users to do? This feature allows users to: Create "save points": Users can explicitly duplicate a project after achieving a stable or desirable state, effectively creating a snapshot of their work. Experiment safely: Users can then make potentially destructive edits or explore new design variations on the duplicated project without impacting the original "good" version. Revert to previous states: In case of errors, undesirable changes, or a need to compare different iterations, users can easily revert to any of their previously replicated project versions. Streamline development workflow: By enabling non-destructive editing and version control, users can iterate on their applications more efficiently and with greater confidence.
AI Context: Python Library
User problem Users struggle to incorporate proprietary or specialized Python libraries into their data applications built with Plotly Studio, limiting the functionality and customization of their generated apps. This often leads to manual workarounds or an inability to fully leverage their existing codebases. What is it? This feature introduces a mechanism for Plotly Studio to integrate with and understand external Python libraries, including private and open-source packages. This integration allows Plotly Studio to access and interpret the Application Programming Interface (API) of these specified libraries. What does it allow users to do? This feature allows users to: Reference any Python library: Users can specify a particular Python library, whether it's a private internal tool or a publicly available open-source package. Leverage custom functions: Once the library is referenced, Plotly Studio can crawl its API, enabling users to incorporate custom calculations, data transformations, and other functions from that library directly into their data applications during the generation process. Enhance application capabilities: Users can build more sophisticated and tailored data applications by utilizing the specific functionalities provided by their chosen external libraries, reducing the need for manual coding or workarounds.
Chat-driven Generation
User Problem Users currently face a steep learning curve and lack of flexibility when creating applications and components like charts and tables using the platform's existing specification-based approach. Difficulty with Format: It's often unclear what format or structure the prompt should follow, leading to overwhelming complexity and trial-and-error. Slow Iteration: The process is slow, taking around 30 seconds for each chart to generate. This forces users to craft comprehensive, detailed initial instructions instead of allowing for quick, fluid, and iterative adjustments. This leads to a less intuitive experience where users spend too much time defining requirements upfront instead of getting instant visual feedback. What is it? The new Chat-driven Generation feature provides an intuitive, conversational interface for building data applications and components. It uses a Large Language Model (LLM) within a chat environment to interpret user instructions, dynamically generating the component, and creating a specification to accompany it. It shifts the creation process from a rigid, spec-based method to a guided, conversational workflow, without losing the benefits of a spec for judging a component’s accuracy and sharing with colleagues. What does it allow users to do? Chat-driven Generation empowers users with a more natural and efficient way to build. It allows users to: Iterate Fluidly: Users can issue individual, rapid instructions to quickly adjust or refine a chart, guiding the LLM toward the final result in a dynamic, step-by-step conversation rather than waiting for long initial builds. Attach Context Easily: The chat environment naturally retains the conversation history, allowing users to effortlessly attach context from previous instructions to their current request. Inspect and Save Specifications: While the user interacts with the chat, the system automatically generates an underlying specification (the code for the component). Users can inspect this specification for accuracy, save it permanently, and share it with colleagues to ensure reproducibility and collaboration. Use Generated Specs as Context: Saved specifications can be used as the starting point or context for future chart creation, streamlining repetitive tasks or building variations on existing designs.
Drag and Drop Layouts
User Problem Users find the current method for rearranging and resizing components in their Plotly Studio applications to be cumbersome and confusing. They must navigate to the Layout tab and manually edit a descriptive prompt that lists components and their sizes (e.g., "Sales Revenue (50%)"). This indirect, text-based approach is often a source of frustration and errors, detracting from the intuitive experience users expect when designing their app's layout. What Is It? This feature is an interactive, drag-and-drop layout editor integrated directly into the Plotly Studio application interface. It replaces the current text-prompt-based layout editing process. The editor provides a visual canvas that represents the app's current layout, allowing users to manipulate components directly, similar to a modern design tool. What Does It Allow Users to Do? This new editor allows users to: Move Components: Users can click, hold, and drag any component—such as a graph, table, or control—to a new position within the application layout, instantly repositioning it. Resize Components: Users can click and drag the edges or corners of a component to easily adjust its width (and row height?) visually, seeing the changes immediately reflected in the layout. Intuitively Design Layouts: Users can manage the entire application design process—including component placement, spacing, and sizing—with a direct manipulation interface, eliminating the need to interpret or edit a code-like descriptive prompt. Simplify Workflow: Users can eliminate context-switching by making layout changes directly within the visual interface, speeding up the design and iteration process.
Enhanced Performance with Large Datasets
User Problem Users of Plotly Studio are currently limited in the size and performance of the datasets they can analyze within their applications. The current 200MB cap and reliance on Python's Pandas library for all data querying and manipulation lead to a sluggish experience. For instance, applying a new filter to the data causes the entire application to freeze or show loading bars for a significant duration, similar to the initial load time. Users are requesting the capability to work with datasets that are an order of magnitude larger while maintaining a responsive and fast application experience. What is it? This feature involves a foundational re-architecture of the data handling and querying engine within Plotly Studio applications. This shift would replace the current Pandas-based, in-memory processing with a high-performance database technology like DuckDB or a similar optimized solution. The goal is to achieve significantly higher data throughput and faster query execution, ideally gaining performance as a side effect of switching to the new technology stack. This migration is the first step toward eventually backing applications with a native SQL layer rather than Python, which will enable future features to push query execution directly down to the original connected database. What does it allow users to do? This performance upgrade will allow users to: Work with much larger datasets: Users will be able to load and analyze datasets that are significantly larger than the current 200MB limit, opening up the analysis of high-volume business data. Experience faster, more responsive interactions: Core operations like applying global filters, aggregating data, or performing calculations will be nearly instantaneous, eliminating the frustrating loading times and application freezes that currently occur with moderately sized data. Build more complex, performant applications: Users can design more sophisticated, data-intensive applications without compromising on speed or user experience, leading to richer insights and more powerful data dashboards. Scale their data analysis: The ability to handle larger data volumes efficiently provides a clearer path for users to scale their analytical workflows as their data needs grow.
Data Chat for App Viewers
User Problem Users who interact with dashboards generated by Plotly Studio lack a direct, simple way to ask follow-up questions or gain deeper insights from the underlying data that may not be easily attained by viewing visualizations alone. They may need to know specific facts, understand trends, or get immediate answers related to the charts they are viewing without having to leave the application or consult a data specialist. What Is It? Data Chat for App Viewers is an intelligent, integrated capability designed to empower end-users with natural language querying against the data powering a Plotly Studio app. It acts as a data assistant, leveraging the structure of the data and the visualizations to provide context-aware, analytical responses. What Does It Allow Users to Do? Data Chat for App Viewers allows users to interact directly with the data powering their dashboards and charts through simple text input, enabling them to: Ask pointed questions about specific data points, segments, or filters present in the app. Request trend analysis for the charts they are reviewing, such as "What was the growth rate in Q3?" or "Identify any anomalies in sales data over the last six months." Generate immediate answers to analytical questions they have while reviewing a dashboard, providing instant clarity and reducing the need to manually manipulate data or build new visualizations. Obtain context-specific information related to a chart or dashboard, enhancing their data understanding and decision-making process.
SQL-backed Apps
User Problem Currently, Plotly Studio apps rely on in-memory processing (Pandas) for queries, which can lead to slow performance and scalability issues, especially when handling large datasets or complex analytical operations. Furthermore, the existing architecture requires custom or limited methods for connecting to diverse data sources, complicating the process for users who need to integrate their applications with existing database infrastructure. What Is It? This feature is a foundational architectural enhancement that transitions Plotly Studio apps to be SQL-backed, initially leveraging a high-performance, in-process SQL database technology like DuckDB. This change means that data within the app is treated as an SQL database, and all subsequent in-app queries, filtering, and aggregation operations are executed using SQL. What Does It Allow Users to Do? This enhancement offers several significant benefits: Significantly Increased Query Performance: By utilizing a robust SQL engine, the feature dramatically accelerates the speed at which in-app queries, filters, and aggregations are executed, leading to a much smoother and more responsive user experience, particularly with larger datasets. It also allows the resulting application to go beyond the current 10k row limitation in the table visualization. Robust Built-in Connection Options: The underlying SQL engine immediately provides users with standardized and reliable built-in connection methods to load data from various file types (like CSV, Parquet, and JSON) and other common data sources. Future-Proofing for External Database Connectivity: This foundational transition sets the stage for a longer-term capability where Plotly Studio apps could be enabled to directly push-down queries to separate, external SQL databases (e.g., PostgreSQL, Snowflake, BigQuery). This would allow users to leverage the processing power of their existing external data warehouses without needing to ingest the entire dataset into the app first.
Expanded File Type Support
User Problem Plotly Studio currently restricts direct file uploads to CSV and Parquet formats. Users who work with other common data file types, such as Excel and GeoJSON, face friction because they cannot upload these files directly. This requires them to manually convert or process these files before analysis in Plotly Studio, slowing down their workflow. What Is It? This feature expands the direct file upload capability in Plotly Studio to include a wider range of file formats beyond the existing CSV and Parquet support. The goal is to allow users to upload virtually any data file type that the underlying data parsing tools (like those available in Python) can reliably read and convert into a standard dataframe for visualization and analysis. What Does It Allow Users to Do? This expanded support for file uploads allows users to: Upload Diverse Data: Users will be able to directly upload files in popular formats like Excel (.xlsx, .xls), GeoJSON, and potentially many others, straight into Plotly Studio for immediate use. Streamline Data Import: By eliminating the need for external file conversion or pre-processing steps, users can significantly accelerate their data-to-visualization workflow. They can skip manual steps and immediately begin their analysis. Maintain Focus: Users can keep their entire data analysis and visualization process within Plotly Studio, resulting in a more integrated and efficient experience. Handle Complex Data: The inclusion of formats like GeoJSON specifically caters to users working with geographic and spatial data, enabling them to easily upload and visualize map-based information.
WinGet Support
User problem Some users require a method to install Plotly Studio via the WinGet package management system instead of downloading it manually from the website. Without this capability, IT administrators and advanced users cannot easily deploy or update the software programmatically across multiple machines, leading to repetitive manual intervention and inefficiencies in endpoint software management. What is it? This proposed feature is the distribution of Plotly Studio through the Windows Package Manager (WinGet) repository. If implemented, each new software release would automatically have its manifest uploaded to the WinGet service, making the application available directly through the Windows command-line interface. What does it allow users to do? Automate Installations: Users can install Plotly Studio programmatically using standard WinGet commands, bypassing the need for manual web downloads. Streamline Deployment: IT administrators can integrate the installation process directly into their existing endpoint software management solutions and deployment scripts. Simplify Updates: Users can easily keep the application up to date alongside their other system packages through centralized package management workflows.
Reusable and Shareable Data Sources
User Problem Manually establishing data source connections can be a repetitive and time-consuming process. Currently, users may find themselves spending several minutes configuring the same connection parameters every time they start a new project. This redundancy creates a barrier to entry for new analysis and increases the likelihood of configuration errors. Additionally, within team environments, individual team members often have to reinvent the wheel by setting up their own connections to the same "trusted" data sources, leading to fragmented workflows and inconsistent data access. What is it? Reusable and Shareable Data Sources is a management feature integrated with the platform's data chat agent. It allows users to leverage an interactive, guided setup process to establish a connection once and store it as a persistent asset. This feature is intended for integration into Plotly Cloud Teams, enabling a centralized repository of verified connections that can be managed and shared across an entire data organization. What does it allow users to do? This feature streamlines the transition from setup to insight by providing the following capabilities: Guided Configuration: Users can build complex data connections interactively with the assistance of a chat agent, reducing the technical burden of initial setup. One-Click Reuse: Once a connection is established, users can instantly apply it to subsequent projects without re-entering credentials or parameters. Team Collaboration: Team members can share access to these data sources, ensuring everyone on a project is working from the same "source of truth." Faster Project Onboarding: By eliminating the multi-minute setup phase for known databases, users can bypass administrative hurdles and begin data visualization or analysis immediately.
Deep Research Mode
User problem Data analysis often requires a tedious, manual sequence of cleaning, filtering, and visualizing data to uncover meaningful insights. When faced with complex or broad questions, users frequently struggle with the "blank canvas" problem—not knowing exactly which analytical steps to take or which chart types will best represent the answer. This process is time-consuming and often requires significant technical expertise to ensure the resulting visualizations accurately reflect the underlying data. What is it? Deep Research Mode is an agentic AI analysis environment within Plotly Studio designed for exhaustive data exploration. Unlike standard automated charting, this mode employs a multi-step reasoning agent that breaks down a user’s high-level inquiry into a logical sequence of analytical tasks. It operates as an interactive workspace where the AI performs the "heavy lifting" of data processing and visualization while maintaining full transparency for the user. What does it allow users to do? Deep Research Mode provides a comprehensive set of capabilities for transforming raw data views into actionable narratives: Execute Complex Inquiries: Users can input pointed or broad questions, prompting the AI to architect a custom multi-step analysis plan. Generate Integrated Assets: The tool automatically produces supporting tables and visualizations, culminating in a written summary that directly addresses the initial request. Maintain Creative Control: Users can pause the multi-step process at any point to review progress, branch off into new analytical directions, or pivot the scope of the research. Verify with Chat: To ensure accuracy, users can engage in a side-chat with the project to interrogate specific analysis steps and verify the logic behind the AI's output. Transition to Production: If a generated visualization proves valuable for long-term use, users can save it to their library or embed it directly into an existing application.
Plotly Studio Internationalization
User Problem Many potential users, particularly those who are not native English speakers, find it difficult to fully engage with and utilize Plotly Studio due to the English-only interface, documentation, and menus. This language barrier limits accessibility and hinders global adoption of the platform, preventing a significant segment of the global data science community from realizing the full power of Plotly visualizations. What is it? Multi-language support for Plotly Studio introduces localized translations for the core elements of the platform. This feature focuses on translating the application's user interface (UI), documentation, and interactive menus into several non-English languages. Targeted initial languages could include: French Spanish Portuguese Arabic Chinese The implementation may begin with partial translations—focusing on high-priority elements like menus, tooltips, and basic onboarding steps—to quickly boost accessibility while the full localization is developed. What does it allow users to do? This feature allows users around the world to interact with Plotly Studio in their native or preferred language, which fundamentally changes how they experience the tool: Understand the Interface: Users can navigate, understand, and utilize all features of Plotly Studio (menus, buttons, tooltips) without needing to translate technical terms or instructions, making the platform feel more intuitive. Accelerate Learning and Onboarding: Non-English speaking users can follow documentation and tutorials more easily, speeding up their learning curve and time-to-value with Plotly. Reduce Cognitive Load and Errors: By operating in a familiar language, users can focus their mental energy on data analysis and visualization rather than translating UI elements, leading to a smoother workflow and fewer operational errors. Increase Global Collaboration: Users from different linguistic backgrounds can more effectively share and discuss their work within a universally accessible platform.
Web Content as Context
User Problem Users often need to generate applications or components (charts, tables, etc.) based on external reference information found on the web, such as up-to-date documentation or specific articles. The LLM, trained on historical data, cannot natively access the current, full content of a specific URL or the latest information found through a web search. This leads to outputs that can be outdated, inaccurate, or fail to follow the instructions contained on a specific web page. What is it? Web Context enables the Plotly Studio LLM to fetch and integrate real-time or specific web content into its context. This is achieved by allowing users to provide one or more URLs (links to websites, documentation pages, etc.). The system will retrieve the text content from the specified source(s) and use it to "ground" the LLM's response. What does it allow users to do? This feature allows users to ensure the LLM generates artifacts based on the most relevant and current information available on the public web. Specifically, users can: Specify a Content Source: Provide specific URLs (e.g., a link to a REST API documentation page or a public data report) to ensure the LLM's generated code, charts, or tables are based on that precise source content. Generate Accurate Code and Designs: Direct the LLM to follow live design standards or technical specifications hosted on a website, reducing the need for manual corrections and speeding up the development of accurate, well-contextualized applications. Maintain Context Scope: Attach URL context to an entire project or to an individual component being generated, allowing for global or surgical context infusion into the LLM's task.
Secrets Support
User problem Users currently lack a secure and centralized way to store and manage sensitive credentials (like API keys or database passwords) that are required by their Plotly applications. Storing these directly in application code or configuration files risks exposure in source control, application logs, or during debugging, especially in environments involving large language model (LLM) requests. They need a mechanism to use credentials within their applications without the risk of them being unintentionally leaked. What is it? Secrets in Plotly Studio is a new capability for secure credential storage within Plotly Cloud. It provides a dedicated, safe location for users to define and manage their sensitive information as groups of key\/value pairs. The first implementation of this feature will be leveraged by Data Views feature, without a UI to manage secrets independently, with a management UI to follow in a subsequent release. What does it allow users to do? It allows users to: Store and organize sensitive credentials (secrets) securely in the user’s computer keychain and in Plotly Cloud. Safely access these stored secrets within their Plotly applications using a new dedicated secrets library. Prevent accidental leakage of sensitive credentials, as the secrets library is designed to ensure the values are not exposed in LLM requests or application logs. Provide secure access to other Plotly features, such as the upcoming Data Views feature, by providing the necessary credentials through this secure mechanism.