RX5 Development:
Rust SDK and Compiler
Explore the planned Rust SDK, compiler and compatibility workflow. Named SDK builds and runnable RX5 examples are not yet published.
RX5 Rust SDK and Compiler Availability
The proposed RX5 development path uses Rust for bots and indicators. Use the record below to distinguish the development scope from an available software release.
Swipe horizontally to view all columns.
| Part | Intended role | Release evidence |
|---|---|---|
| Rust SDK | Strategy/indicator interfaces, market-data access and permitted trading actions. | Package, API reference and tested version: not yet published. |
| Compiler and runtime | Build the supported source into an artifact that can run in an approved RTX5 environment. | Compiler version, target format and runtime compatibility: not yet published. |
| Desktop testing | Validate the algorithm against declared historical data and execution assumptions. | Tested desktop build, sample data and runnable example: not yet published. |
| Broker-hosted instance | Operate an approved artifact with broker-defined permissions and resource limits. | Available runtime build, deployment procedure and access scope: to be confirmed. |
A Proposed Development Workflow
The RX5 workflow is planned around Rust source, desktop testing and approved hosting. Available SDK versions, runtime interfaces and original examples must be published before runnable instructions are offered.
Strategy Creation
Design Rust strategy logic within the published data and permission scope.
Test & Optimize
Plan reproducible desktop tests using licensed fixtures and declared execution assumptions.
Real-Time Execution
Request approval for the tested artifact and a compatible broker-hosted runtime.
Unified Workflow
Track source, compiler, desktop tests and runtime approvals across the proposed workflow.
Powerful Tools for Developers
Planned tools for source preparation, desktop validation and an approved runtime handoff.
Integrated Code Editor
The proposed editor workflow prepares Rust source against a named SDK. Editor features will be documented with the available build.
Rust project — SDK pendingStrategy Development
Define strategy parameters and the specific licensed data and trading permissions each strategy needs.
Example: define parametersBacktesting Engine
Desktop backtesting is planned. Preserve data, costs and fill assumptions; a simulated outcome does not predict live returns.
No tested result publishedReal-Time Debugging
Diagnostic and debugging support must be confirmed for the released compiler and desktop build.
Diagnostic example pendingApproved Deployment
Submit a tested artifact for broker approval. Hosting requires compatible runtime, account permissions and agreed resource limits.
Runtime approval requiredRust and Source Migration
RX5 development is planned in Rust. Authorized Pine, MQ5 and MQH conversion covers only published subsets, with manual review.
Rust SDK — version pendingFrom Idea to Execution
The proposed lifecycle separates development, desktop validation and broker approval; it does not promise a flawless or profitable deployment.
1. Write your strategy code
Prepare Rust source against the published SDK version; editor features await a tested release.
2. Test using historical data
Use authorized historical data with declared source, coverage, costs, fills and missing-data handling.
3. Optimize performance
Separate training and evaluation windows, record parameters and avoid selecting only favorable results. Optimizer support is not yet published.
4. Request runtime approval
Submit the reviewed artifact, permission scope and desktop test bundle to the broker before hosting.
5. Monitor and improve
For an approved instance, reconcile current state, monitor errors and verify stop behavior before modifying the strategy.
Compile on Desktop and Approve a Hosted Instance
This proposed handoff describes what should travel with a strategy from development to deployment. Runnable installation and compiler commands depend on an available SDK release.
- 01
Prepare the Rust project
Record the SDK/compiler version, source revision, dependencies and required permissions. For migrated source, preserve rights and the conversion review alongside the project.
- 02
Compile and test on desktop
Retain build diagnostics, the output artifact identity, historical-data reference and test configuration. Review fills and behavior rather than only a summary performance metric.
- 03
Request broker approval
Submit the reviewed artifact, configuration and required data/trading access. Agree account scope, permitted instruments, runtime quota and how the instance can be stopped.
- 04
Monitor the approved version
Identify the active artifact and settings in the instance record. Review errors, resource use and order activity; a changed artifact or expanded permission set requires another review.
Illustrative RX5 instance
Planned monitoring example; no live instance or results are shown.
Automate with Precision
The planned RX5 runtime would execute approved Rust strategy logic within broker permissions. Build support and operating limits require verification before deployment.
Hosted Execution
A hosted instance is intended to operate independently of the phone. Session availability, recovery and stop behavior depend on the tested runtime and broker plan.
Defined Strategy Logic
Rules make intended behavior explicit; defects, data gaps and market conditions still require testing and supervision.
Planned Development Scope
Use these areas to scope an RX5 project. They describe intended capabilities, not a released library or verified performance claim.
Custom indicators creation
Plan Rust calculations and chart output using the data and display interfaces published for the supported SDK.
Algorithmic trading support
The library inventory, supported instruments and strategy interfaces remain subject to a versioned SDK release.
API integrations
External data and network access require declared permissions and published API/runtime support; arbitrary integrations are not assumed.
Data-driven strategy building
Historical depth, tick resolution and market-data entitlements depend on the licensed source and documented SDK interfaces.
Real-time execution control
Order actions require account authorization and broker-side validation. Supported actions and latency measurements await a tested build.
Who Is RTX5 IDE For?
A versatile environment serving different tiers of market participants.
Algorithmic traders
Evaluate rule-based strategies with explicit permissions, failure handling and supervision.
Developers & programmers
Prepare Rust bots and indicators for private evaluation; marketplace publishing remains planned.
Quantitative analysts
Design reproducible model tests with licensed datasets and a compatible desktop build.
Advanced traders
Enhance your manual trading with custom visual indicators, alerts, and semi-automated scripts.
Performance Requires Evidence
The planned Rust/RX5 toolchain has no published benchmark record here. Validate latency, resource use, recovery and capacity with the exact build before relying on a performance claim.
High-speed execution
Publish execution measurements only with the runtime build, hardware, workload and measurement method. No latency result is verified here.
Efficient processing
Parallel processing and supported resource use require build-level tests; all-core execution is not yet confirmed.
Stable development environment
Recovery and persistence need tests against an identified editor build. Keep independent source revisions and backups.
Scalable architecture
Supported instruments and concurrent strategy limits must be measured for the intended client and runtime plan.
Planned Platform Integration
RX5 integration depends on the published SDK, client and runtime contracts. This overview does not establish universal compatibility or remove approval requirements.
Trading Platform
Desktop integration requires a tested client/SDK combination. Navigator and loading behavior are not yet published.
Virtual Hosting (VPS)
Broker hosting is planned for approved artifacts. Available regions, deployment steps, quotas and latency require a specific plan and test record.
Signals Network
Signal distribution is a separate permission and product scope. No subscriber count or automatic distribution capability is established here.
Unified Ecosystem
Record compatible versions at each development, desktop-test and hosting stage before approving a complete workflow.
Development Security Requirements
Retain ownership and authorized dependency records for each strategy. Publish tested sandbox, transport and artifact-handling details before making security or intellectual-property protection claims.
Safe code execution
Sandbox and file-access boundaries require published policy and permission-denial tests for the named runtime build.
Secure data handling
Artifact protection, distribution rights and marketplace handling must be documented and reviewed; encryption or IP protection is not guaranteed here.
Protected deployment systems
Deployment transport, artifact identity and runtime authorization need verified configuration. No zero-knowledge transfer claim is made.
Security Status
Verification pending
Build, Test and Automate Your Trading Ideas
RTX5 IDE is planned as a Rust/RX5 environment for developing trading strategies and indicators. Compiler, SDK and runtime versions require publication.
Develop
Proposed authoring of Rust/RX5 strategies, indicators and trading logic.
Test
Historical testing, performance evaluation and optimization where available.
Deploy
Proposed deployment of validated RX5 packages to an approved broker runtime.
Risk
Automated strategies should operate within defined risk controls and trading limits.
- 01
Idea
- 02
Build
- 03
Test
- 04
Validate
- 05
Deploy
- 06
Monitor
Features that are not yet released are labelled In Development or Coming Soon. Automatic conversion of any Pine/MQ5 strategy is not promised.
Start Building the
Future of Trading
Request the current Rust SDK scope and evidence needed to begin a compatible RX5 project.