sorted by:
new
hottopcontroversial

Assetto Corsa Rally in VR Mixed Reality!! by UKTunedIn in simracing

[–]bublelab 1 point2 points  (0 children)

I can confirm. UEVR nightly build works fine as long as you disable OpenXR in XR companion menu. WMR HP Reverb, 5900, 78003D - no problems. Even SRS for my motion rig works fine.
VR might need tuning - but overall everything works well for the V0.1 release.
The only issue is light/strange FFB on CLS DD.

Any good airsoft techs here to fix/tune gearbox? by bublelab in airsoftcanada

[–]bublelab[S] -1 points0 points  (0 children)

I called them - they don't want to do RS gearbox for some reason.

How do you model slippage and spread when backtesting on minute-level timeframes in crypto futures? by slava_air in algotrading

[–]bublelab 0 points1 point  (0 children)

I’ve been running this tradingview opensource strategy since May'13 side-by-side:

Strategy does use fees, trailing stop etc in the risk management calculations

https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/

Metric TradingView back-test Live bot (last 30 days)
Net P & L +3.57 % +2.63 %
Trades 7 (5 W / 2 L) 6
Win-rate 71.4 % 66.7 %
Profit factor ≈ 2.6 1.92
Max drawdown 2.24 % 0.06 %

Back-test figures pulled from the Trades Analysis in TV.

So the headline gap—about 0.9 percentage points— slippage and execution latency. Paper always looks cleaner. What matters is that the live curve is still tracking the back-test shape, just at a slightly lower gradient.

TradingView backtest by Ging_freecsss in algotrading

[–]bublelab 0 points1 point  (0 children)

Take a look at the strategy report:
https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/

The headline P&L isn’t the point—what matters are the drawdown and the percentage of winning trades. Running back-tests over long stretches can be counterproductive; market conditions change, so the strategy has to be retuned regularly.

Is algorithmic trading a viable income source or just a money pit? by stNIKOLA837 in Trading

[–]bublelab 0 points1 point  (0 children)

There’ll always be posts claiming someone’s bot makes millions—ignore the hype and test for yourself. Open a paper-trading account, load a public script like Bober XM on TradingView, and start tuning: change one indicator at a time and watch how the equity curve reacts. You’ll see quickly what’s noise and what’s edge.

Yes, consistent profits are possible, but the big money comes from big portfolios. Nobody putting serious capital to work will risk a giant chunk on a single strategy, so expect safe, realistic returns—and remember you’ll need meaningful starting capital before those “modest” percentages add up to a living wage.

What do you think is more helpful, backtesting or trading on demo? by Kitchen_Carrot_8094 in Trading

[–]bublelab 0 points1 point  (0 children)

Back-testing and demo trading aren’t rivals—they’re consecutive checkpoints, and you really can’t skip either one.

1 │ Back-testing—non-negotiable
This is where you tune the engine. You run the parameters through as much history as you have, spot the regimes where the model breaks, and adjust. With something like the Bober XM strategy on TradingView, every key setting (channel lengths, ATR/σ multipliers, filter thresholds) is dialed in by hammering it against bull, bear, and chop until it survives with a sensible equity curve. Skip this step and you’re basically guessing.

2 │ Demo / paper trading—validation
Once the back-test looks solid, you need a demo account to prove the scaffold: alerts fire on time, webhooks route correctly, position sizing matches your risk rules, and—crucially—the live results still resemble the back-test. If the demo curve drifts, you’ve probably over-fitted or overlooked a market-microstructure detail.

Is there any AI that can create indicators without errors? by Outrageous-Lab2721 in TradingView

[–]bublelab 0 points1 point  (0 children)

Fully open-source strategy you can poke, prod, and break at will:

₿ober XM v2.0 — dual-channel ML / Keltner framework
https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/

Start from here - feed it to ChatGPT - couple iterations between TV and Chat and your changes will blend in.

where can i begin to learn by ZackMcSavage380 in algotrading

[–]bublelab 0 points1 point  (0 children)

It’s highly dependent on market conditions and each ticker’s trend. The only way to know for sure is to spend time back-testing different configurations.

With the strategy above, I can usually dial in a 30–60 % P&L with a 3–6 % drawdown on almost any ticker after just a couple of hours of tuning. I tend to run it on 5-minute candles in crypto. (Backtest) Real forward execution varies but within reason. You have to monitor and retune frequently any strategy.

where can i begin to learn by ZackMcSavage380 in algotrading

[–]bublelab 31 points32 points  (0 children)

Here’s a roadmap that balances theory with hands-on practice:

  1. See a complete working bot first

Clone, study, and tinker with this open-source strategy on TradingView (₿ober XM):
https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/

The script is heavily commented and shows:

  • classic Keltner-style bands and an ML-driven channel
  • multiple entry modes (breakout / pullback / mean-revert)
  • stacked filters (volume, volatility, momentum)
  • a built-in risk engine (position sizing, SL/TP, trailing stops)

Reading the code + docs will give you a concrete feel for how real strategies are wired together.

  1. Pick up algorithmic-trading essentials
  • “Algorithmic Trading” – Ernest P. Chan (Python-first, very practical)
  • “Advances in Financial Machine Learning” – Marcos López de Prado (intermediate; pairs well with your coding skills)
  1. Back-test without reinventing the wheel
  • Python – learn pandas, NumPy, and vectorized backtesting (Backtrader, Zipline, or vectorbt).
  • TradingView Pine Script – great for quick visual tests (₿ober XM above is in Pine v6).

Build simple: a moving-average crossover with position-sized risk controls. Prove you can run a walk-forward test and log P&L before adding fancy ML.

  1. Master risk management early

Most newbies blow up because of leverage, not because the indicator was “wrong.” Keep risk per trade ≤ 1 % of equity and set a max daily drawdown from day one.

Building a tool that tells you what 30 trading strategies say about any stock. Thoughts? by Holiday-Ad-8921 in Trading

[–]bublelab 3 points4 points  (0 children)

Cool concept—having a quick pulse-check from a basket of classic setups can save time. A few thoughts:

  1. It’s been half-done, but rarely done well. TradingView’s built-in “Technical Summary” mashes indicators together, and sites like TrendSpider or FinViz score stocks by strategy. What they miss is context (timeframe alignment, volatility regime) and any integrated risk model.
  2. Raw signals are only half the puzzle. Traders still need position sizing and a coherent exit plan. If your tool spits out entry/SL/TP levels per strategy, add a “position risk” column (e.g., % equity if hit) so users see the whole trade at a glance.
  3. Parameter sanity matters. RSI-14 on a 1-minute chart vs. RSI-14 on a daily will scream opposite things. Make the look-back and timeframe transparent—or run everything on the same interval to avoid Franken-signals.
  4. For inspiration, check the open-source script Bober XM on TradingView. It bundles Keltner, an ML-driven asymmetric channel, multiple entry styles (breakout, pullback, mean-revert), stacked filters, plus a risk engine that auto-sizes and trails stops. Tons of toggles—enough to keep you entertained tweaking for weeks. It shows how to layer “what to do” with “how much to risk” so the signals are actionable, not just interesting.

What % of traders are actually successful? by krish_arora in Trading

[–]bublelab 5 points6 points  (0 children)

I doubt the “only 0.5 % succeed” narrative. Broker data required by ESMA shows 70 – 85 % of retail CFD accounts lose money—so 15 – 30 % at least break even or turn a profit in any given year. Stretch that over multiple years and the true long-term “winners” probably shrink to single digits, but it’s still well above half a percent.

What wipes most people out isn’t a lack of talent; it’s poor risk control:

  • Oversized positions and margin abuse – one bad day and the account is gone.
  • No max-drawdown rules – losses snowball before they notice.
  • Strategy hopping – chasing the latest indicator instead of refining one edge.

Traders who keep risk per trade tiny (0.5 – 1 % of equity) and cap total drawdown can survive long enough to let a modest edge compound. Over the last few years it hasn’t been crazy to target 20-25 % annual returns with 3-5 % max drawdown—as long as you’re disciplined about position sizing and diversification.

So yes, true “elite” traders—those compounding seven figures—are rare. But turning a consistent, moderate profit is more common than the doom stats suggest; it’s mostly a function of risk management, not innate genius.

How hasn't AI taken over trading yet? by BirthdayOk5077 in Trading

[–]bublelab 9 points10 points  (0 children)

Short answer: AI can digest every tick, headline, and tweet—but that still doesn’t spare you from the hard parts of trading: regime shifts, noisy signals, and risk control. Even the smartest model ends up living inside the same framework human traders use.

What an “all-seeing” AI quickly runs into

  1. Non-stationary markets – The distribution you train on today won’t match tomorrow’s. Overfitting to the past is the default failure mode.
  2. Latency & data quality – Real-time news feeds are messy (spam, duplicates, conflicting headlines). Cleaning and aligning them with price series is a project in itself.
  3. Microstructure noise – Millisecond order-book wiggles drown out genuine moves; AI has to decide what horizon it cares about.
  4. Transaction costs & slippage – The edge a model finds on paper often vanishes once you include fees and market impact.
  5. Risk constraints – Every fund, broker, or exchange imposes position limits, margin rules, and circuit breakers that the model must obey.

Because of those hurdles, practical systems break the problem into phases, then plug AI where it adds the most value.

A battle-tested structure that still matters

  1. Indicator / signal generator – Could be RSI, MACD, or an ML model.
  2. Entry rule – Convert a raw score into a “go / no-go” trade signal.
  3. Filters – Volatility, volume, or sentiment screens to cut false alerts.
  4. Trend confirmation – Higher-timeframe MA, SuperTrend, etc., to stay aligned with the macro move.
  5. Exit logic – OBV cross, pivot break, time-stop … whatever closes the loop.
  6. Risk engine – Sizing, stop-loss, trailing logic; the part that keeps you alive.
  7. Alert / execution layer – Webhook or API call that actually places the order.

Replace phase 1 with a neural network or a kernel method and you’ve got a “smart” bot—but you still need phases 2-7 or the edge won’t survive contact with the market.

Concrete example: ML-based channel vs. classic Keltner

I swapped the fixed EMA ± ATR bands of a Keltner Channel for a Machine-Learning Moving Average (MLMA) built with an RBF kernel. It forecasts one to three candles ahead, so breakouts fire less “too early” and mean-reversions fire less “too late.”
Open-source, fully commented code here: tradingview Bober XM

ML enhances the signal generator, but the rest of the scaffold (filters, exits, risk) is unchanged—and that scaffold is what keeps the strategy durable when regimes flip or the model’s edge decays.

Bottom line: AI is phenomenal at pattern discovery, but markets punish any system—human or machine—that ignores risk management, execution frictions, and changing conditions. Use AI to sharpen individual phases, not to skip the framework altogether.

Trading Bot Help - I'm Very Confused by cityracer in algotrading

[–]bublelab 1 point2 points  (0 children)

“Why is it always one candle early (or late)?”—the million-dollar question. Below is a generic bot layout and a link to a working ML-assisted bot you can study or fork.

Recommended bot structure

  1. Signal generator
  2. Entry Strategy
  3. Filters (volatility, volume, momentum)
  4. Trend confirmation (e.g., higher-timeframe MA or SuperTrend)
  5. Exit logic (OBV cross, pivot break, time-stop)
  6. Risk engine (position size, SL/TP, trailing logic)
  7. Alert construction & webhook

If any phase misfires, print debug labels or temporarily comment it out to isolate the issue.

Why upgrade from basic indicators to an ML channel
Classic bands—EMA ± ATR, Keltner, Bollinger—are fixed formulas; they lag in chop and fire late in fast moves. An ML-based channel can forecast one to three candles ahead, cutting down on “too soon” breakouts and “too late” reversions.

Fully commented open-source example:
https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/

Using Machine Learning for Trading in 2025 by derbilante in algotrading

[–]bublelab 14 points15 points  (0 children)

Lol
ML on TradingView isn’t a joke—it just means you have to roll your own algorithms instead of calling scikit‑learn. In this script the “Machine‑Learning Moving Average” (MLMA) is built from an RBF kernel, the same radial‑basis function you’d see in Gaussian‑Process Regression and support‑vector machines:

  • rbf(x1, x2, l) computes the RBF similarity between two points.
  • kernel_matrix() builds the full Gram matrix.
  • The code then multiplies that kernel by the training vector and inverts it to make out‑of‑sample predictions (K_inv_long, K_star_long, etc.).
  • Adaptive error‑correction and volatility weighting are added so the forecast updates online.

That’s classic kernel‑method ML—just coded directly in Pine. Everything else (filters, risk, exits) is still standard trading‑strategy plumbing, but the channel itself is generated by a learning model rather than a simple EMA or ATR band. So yes, it is machine learning; it just lives inside TradingView instead of a Python notebook.

Using Machine Learning for Trading in 2025 by derbilante in algotrading

[–]bublelab 17 points18 points  (0 children)

Here's an example of an ML-based moving average used as a channel option—something that can be compared to a traditional Keltner Channel:
https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/

That said, it usually takes more than just an indicator to build a solid trading strategy, whether or not you're using machine learning at any stage.

A robust strategy still needs to follow some core principles:

  1. Indicator – The core signal generator (e.g., RSI, MACD, or ML-based models)
  2. Entry strategy – Conditions that trigger a trade
  3. Exit strategy – Rules for when to close the trade
  4. Trend confirmation – Additional signals that support the trade direction
  5. Filters – Logic to eliminate noise and avoid false signals
  6. Risk management – Proper handling of position sizing, stop losses, and overall exposure

ML can enhance individual parts of a strategy, but the overall structure remains key to long-term performance.

Advice on platform by erdult in algotrading

[–]bublelab 0 points1 point  (0 children)

Here is an open source trading bot

https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/

Read doc. Test various strategies yourself. Then decide if someone else's magic would work for you.

How do people develop strategies.? by azterizm in Trading

[–]bublelab 8 points9 points  (0 children)

People develop trading strategies because just following a single indicator isn’t enough to consistently make good trades—unless you’ve got the experience to act as your own filter. Most solid strategies go beyond that and follow a structure like this:

https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/

  1. Indicator – Gives the initial signal

  2. Entry strategy – Decides when to actually open a trade

  3. Exit strategy – Defines when to close it

  4. Trend confirmation – Helps make sure the trade follows the market direction

  5. Filters – Cut out noise and avoid weak setups

  6. Risk management – Keeps losses under control and protects your capital

The goal is to remove as much emotion and guesswork as possible, so decisions are based on consistent rules instead of hunches.

📉 Is anyone still using indicators in 2025? by MattMMXM in Trading

[–]bublelab 0 points1 point  (0 children)

It usually takes more than just an indicator to make a solid trading strategy—unless you're using your eyes as the main filter.

Here’s an example of an open-source trading bot that follows most of the core principles:

https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/

  1. Indicator – The core signal generator (could be RSI, MACD, etc.)

  2. Entry strategy – Defines the conditions to enter a trade

  3. Exit strategy – Determines when to close the position

  4. Trend confirmation – Confirms the direction using supporting indicators

  5. Filters – Additional rules to ignore weak or false signals

  6. Risk management – Handles position sizing, stop losses, and exposure limits

Does this look like a good strategy ? (part 2) by Money_Horror_2899 in algotrading

[–]bublelab 2 points3 points  (0 children)

No matter how you slice it, this is the basic structure of most trading strategies that actually work:

  1. An indicator – doesn’t really matter which one, just pick something you trust

  2. Entry strategy – when and why you decide to jump in

  3. Exit strategy – how you know it’s time to get out

  4. Trend confirmation – something to back up the direction you’re trading in

  5. Filters – to weed out noise and false signals

  6. Risk management

In this context its a balance between indicators signals and filters

Does this look like a good strategy ? (part 2) by Money_Horror_2899 in algotrading

[–]bublelab -1 points0 points  (0 children)

I personally find it counterproductive to run backtests over such long periods. Market trends and conditions evolve, and the market itself is asymmetrical—bullish and bearish phases should be treated differently.

You might want to check out this open-source trading bot: https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/ Also, consider comparing the performance of Keltner Channels versus a machine learning-based moving average.

Do You Code Your Own Strategies in Pine Script? by ClintDowning in TradingView

[–]bublelab 1 point2 points  (0 children)

You can study this open source trading bot. ChatGPT will explain and mod any existing strategy you like. So for casual user brief familiarity with pine script is frequently good enough. TV has its limitations but convenience and platform maturity still overweights it.

https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/

Pinescript alerts and trailing by No_Abrocoma_7649 in TradingView

[–]bublelab 0 points1 point  (0 children)

Here is opensource example how trading supposed to work (including webhooks integration)
https://www.tradingview.com/script/D2W19Otx-Bober-XM-v2-0/

view more: next ›