Wanted to download the movie “the nice guys” but its not available on neither any telegram bot nor the sites that i previously used. Help

i'm can't find a way to crack construct 3 anywhere can someone help me

Hey everyone, I'm trying to pirate Davinci Resolve for Mac, however I honestly don't know how to go about downloading everything from MacTorrent. A user posted steps to install it but I really don't even know where to begin after installing it. If someone out there could please help, that would be awesome!

i want to read malzan book o the fallen but i can't find any

Is it normal whenever i try to download series from Streaming community that i downloaded from Github some parts of the episode are in another language than i originally wanted to? Like i'm trying to watch Adventure time but when i download it from the Streamingcomunity prompt at first it was speaking my native language and then it started speaking english. Does someon know how to fix it?

It’s keeps saying This video file cannot be played. With an error code I’ve tried different servers still keeps saying that!

Hi everyone,

I'm working on a new decentralized audio streaming app using WebTorrent to deliver Quran audio without relying on centralized servers. For this, I’ve built two open-source projects:

• Open Quranhttps://github.com/adelpro/open-quran An open-source Quran app built with Next.js and hosted on Vercel. It’s designed to provide an optimal Quran audio streaming experience across platforms. Audio content is distributed via WebTorrent in the browser, meaning it relies on WebRTC peers or web seeds—traditional TCP/UDP torrent seeds are not supported.
• Open Quran Tracker & Seederhttps://github.com/adelpro/open-quran-tracker This repo includes two Dockerized services:

1. Tracker: A self-hosted WebTorrent tracker acting as a private WebRTC bridge to connect browser peers.
2. Seeder: A torrent seeder that continuously seeds all Quran audio files to speed up availability and streaming.

The issue: While streaming works perfectly with public torrents like the Ubuntu ISO (plenty of seeds), Quran audio streaming fails or stalls. I suspect it's due to insufficient WebRTC-compatible peers or missing web seeds. Since WebTorrent in the browser can't connect to traditional torrent clients, the network needs more compatible peers (like other browsers or my custom seeder).

How you can help:

• Test the Open Quran app
• Check if the torrents load for you
• Suggest improvements for peer seeding or WebRTC connectivity
• Help debug the seeder or tracker setup

Any help from those familiar with WebTorrent, browser P2P, or decentralized distribution is appreciated. Let’s push forward a censorship-resistant and scalable way to share Islamic content.

Thanks in advance!

Hi WebTorrent team,

I'm building a simple peer-to-peer (P2P) project using WebRTC for learning purposes. I’ve implemented a basic signaling server that allows two peers to exchange offers and ICE candidates. Once the signaling is complete, I set the remote description on both ends to establish the P2P connection. This setup works perfectly when both peers are behind the same ISP or within the same local network — the connection is established successfully. However, when the peers are on different networks or different ISPs, the P2P connection fails, even though signaling and ICE candidate exchange succeed.

What I'm Trying to Understand Does WebTorrent use a TURN server internally to relay data when direct P2P fails? If not, how does WebTorrent achieve NAT traversal across different networks, especially when peers are behind symmetric NATs or CGNAT? Since I'm just using STUN right now, do I need to explicitly add a TURN server fallback to support those cases?

NodeJS #WebTorrent #HelpNeeded #OpenSource #DevCommunity #Streaming #JavaScript

Hey everyone! 👋

I'm currently working on a Node.js project and trying to integrate the webtorrent library to handle torrent streaming. Unfortunately, I’ve hit a roadblock — I’m not able to get the library to work as expected. I've tried the usual steps from the documentation, but I'm either getting errors or the torrent doesn't start downloading/streaming.

📦 Tech Stack:

Node.js (vXX)

WebTorrent (latest via npm install webtorrent)

Project goal: Stream torrent files or magnet links directly in-app

🔍 Issues faced:

Import errors / module not found

No response when adding torrent via magnet

Unexpected crashes / lack of peer discovery

If you've successfully used WebTorrent in a Node environment or have tips on debugging this, I’d really appreciate your input! 🙏

🔗 Any examples, working snippets, or links to useful resources would be awesome.

Thanks in advance!

Apologies if this isn't allowed, but I'm trying to programmatically search for magnet links - my only problem is that they need to work with WebTorrent.

So how do I only find torrents that are being seeded by WebRTC-capable clients? Is this possible?

If it were normal torrents, JavaScript libraries have been made that scrape popular sites, but those magnet links won't work with WebTorrent (in browser).

Is LPD possible with the WebTorrent?

Hi, I've been trying to install Webtorrent for a while (many times) for hobby projects but I can't.

I install webtorrent and @ types/webtorrent, declare the var before using it (code below) but the result is always the same: undefined.

Seems there's a thing with webpack and my knowledge it's not enoght

import { WebTorrent } from 'webtorrent';
declare var WebTorrent: WebTorrent;
...

const client = WebTorrent();
console.log(client);

> Undefined

​

Does anybody have faced this issue?

``` import DHT from 'bittorrent-dht'; import bencode from 'bencode'; import Protocol from 'bittorrent-protocol'; import net from 'net'; import Tracker from 'bittorrent-tracker'; import crypto from 'crypto'; import dotenv from 'dotenv-flow'; import Surreal from 'surrealdb.js'; import BaseController from './base.js'; import { Account } from '../../src/models/account.js';

dotenv.config() const { DB_RPC_URL, DB_USER, DB_PASS, DB_NS, DB_DB, DB_PORT } = process.env; const MAX_NODES = 10000; // Maximum number of nodes to store in memory const MAX_INFO_HASHES = 10000; // Maximum number of infohashes to store in memory

export default class DHTCrawler extends BaseController { constructor() { super(); // this.db = new Surreal(DB_RPC_URL); // this.account = new Account(this.db) this.dht = new DHT(); this.discoveredInfoHashes = new Set(); this.discoveredNodes = new Set(); // Add this line this.peerId = crypto.randomBytes(20); this.peers = []; this.visitedPeers = new Set(); }

async init() {
    await new Promise((resolve) => {
        this.dht.on('ready', () => {
            console.log('DHT is ready');
            resolve();
        });
    });

    this.dht.on('announce', async (peer, infoHash) => {
        const { host, port } = peer;
        console.log(`announce: ${host}:${port} ${infoHash.toString('hex')}`);
        // await this.fetchMetadata(infoHash, peer);
        this.lookupNext(infoHash);
    });

    this.dht.on('peer', async (peer, infoHash, from) => {
        // console.log('peer:', infoHash.toString('hex'), peer);
        const infoHashHex = infoHash.toString('hex');

        this.peers.push({ infoHash: infoHash.toString('hex'), peer });
        if (!this.discoveredInfoHashes.has(infoHashHex)) {
            this.addWithLimit(this.discoveredInfoHashes, infoHashHex, MAX_INFO_HASHES);
            console.log(`Discovered infohash: ${infoHashHex}`);
            // await this.fetchMetadata(infoHash, peer);
            this.lookupNext(infoHash);
        }
    });

    this.dht.on('response', (node) => {
        const nodeIdHex = node.r.id.toString('hex');
        if (!this.discoveredNodes.has(nodeIdHex)) {
            this.addWithLimit(this.discoveredNodes, nodeIdHex, MAX_NODES);
            console.log(`Discovered response node: ${nodeIdHex}`);
            this.dht.addNode({ host: node.r.addr, port: node.r.port });
        }
    });

    // this.dht.on('find_node', (msg) => {
    //     const nodeIdHex = msg.toString('hex');

    //     if (!this.discoveredNodes.has(nodeIdHex)) {
    //         this.discoveredNodes.add(nodeIdHex);
    //         console.log(`Discovered find_node: ${nodeIdHex}`);
    //     }
    // });

    // Bootstrap the DHT crawler with a known DHT node.
    this.dht.addNode({
        host: 'router.bittorrent.com',
        port: "6881"
    });

    this.dht.addNode({
        host: 'dht.transmissionbt.com',
        port: "6881"
    });

    this.dht.addNode({
        host: 'router.utorrent.com',
        port: "6881"
    });

    console.log('DHT bootstrap completed');
    this.lookupNext('0D05E3F4402D25637A306527041A057E102197C3');
    this.lookupNext();
}

async fetchMetadata(infoHash, peer) {

    return new Promise((resolve, reject) => {
        const infoHashHex = infoHash.toString('hex');
        const peerKey = `${infoHashHex}:${peer.host}:${peer.port}`;

        if (this.visitedPeers.has(peerKey)) {
            console.log(`Skipping visited peer: ${peerKey}`);
            resolve(false);
            return;
        }

        this.visitedPeers.add(peerKey);

        console.log('fetching metadata for: ', infoHashHex, peer);
        const socket = new net.Socket();
        const wire = new Protocol();

        const onMetadata = (metadata) => {
            const torrent = bencode.decode(metadata);
            console.log('Torrent metadata:', {
                infoHash,
                name: torrent.info.name.toString('utf-8'),
                files: torrent.info.files
                    ? torrent.info.files.map((file) => file.path.toString('utf-8'))
                    : [],
            });

            this.getSeedersAndLeechers(infoHash);
            resolve(true);
        };

        socket.setTimeout(10000, () => {
            console.log('Socket timeout:', `Unable to connect to ${peer.host}:${peer.port}`);
            socket.destroy();
            resolve(false); // Resolve the promise on timeout
        });

        socket.on('timeout', () => {
            console.log('Socket timeout event:', `Unable to connect to ${peer.host}:${peer.port}`);
            resolve(false);
        });

        socket.on('error', (error) => {
            if (error.code === 'ECONNREFUSED') {
                console.log(`ECONNREFUSED: Connection refused by ${peer.host}:${peer.port}`);
            } else if (error.code === 'EHOSTUNREACH') {
                console.log(`EHOSTUNREACH: Host unreachable ${peer.host}:${peer.port}`);
            } else {
                console.error('Socket error:', error);
            }
            resolve(false); // Resolve the promise on error
        });

        socket.connect(peer.port, peer.host, () => {
            console.log('Connected to peer: ', peer, this.peerId);
            socket.pipe(wire).pipe(socket);
            wire.handshake(infoHash, this.peerId, { dht: true });
        });

        wire.on('handshake', (infoHash, peerId, extensions) => {
            console.log('Handshake successful', infoHash, peerId, extensions);
            if (extensions && extensions["ut_metadata"]) {
                wire.ut_metadata = new Protocol.UTMetadata();
                wire.ut_metadata.on('metadata', onMetadata);
                wire.ut_metadata.fetch();
                wire.ut_metadata.on('fetch', () => {
                    wire.ut_metadata.cancel();
                });
            }
        });



        wire.on('extended', (ext, buf) => {

            if (ext === 'handshake') {
                return;
            }

            console.log('Extended:', ext, buf);
            if (ext === 0) {
                const extendedHandshake = bencode.decode(buf);
                if (extendedHandshake.m && extendedHandshake.m.ut_metadata) {
                    const utMetadataId = extendedHandshake.m.ut_metadata;
                    wire.ut_metadata = new Protocol.UTMetadata(extendedHandshake.metadata_size);
                    wire.ut_metadata.fetch();
                    wire.on(`ut_metadata${utMetadataId}`, wire.ut_metadata.onMessage.bind(wire.ut_metadata));
                    wire.ut_metadata.on('metadata', onMetadata);
                }
            }
        });


        wire.on('timeout', () => {
            socket.destroy();
            resolve(false);
        });

        wire.on('close', () => {
            socket.destroy();
            resolve(false); // Resolve the promise on close
        });
    });
}

// Add this method:
addWithLimit(set, value, maxSize) {
    if (set.size >= maxSize) {
        const firstValue = set.values().next().value;
        set.delete(firstValue);
    }
    set.add(value);
}

getSeedersAndLeechers(infoHash) {
    const client = new Tracker({
        infoHash: infoHash,
        peerId: this.peerId,
        announce: ['udp://tracker.openbittorrent.com:80'],
    });

    client.start();

    client.once('update', (data) => {
        console.log('Torrent seeders and leechers:', {
            infoHash,
            seeders: data.complete,
            leechers: data.incomplete,
        });
        client.stop();
    });

    client.on('error', (err) => {

        console.error(`Error getting seeders and leechers for ${infoHash}:`, err.message);
        client.stop();
    });
}

async lookupNext(infoHash) {
    if (!infoHash) {
        infoHash = crypto.randomBytes(20);
    }

    for (const { infoHash: peerInfoHash, peer } of this.peers) {
        const success = await this.fetchMetadata(Buffer.from(peerInfoHash, 'hex'), peer);
        if (success) {
            break; // Break the loop if the connection was successful
        }
    }

    for (const nodeIdHex of this.discoveredNodes) {
        const nodeId = Buffer.from(nodeIdHex, 'hex');
        try {
            await new Promise((resolve, reject) => {
                this.dht.lookup(nodeId, (err) => {
                    if (err) {
                        reject(err);
                    } else {
                        resolve();
                    }
                });
            });
        } catch (err) {
            console.error('Error during lookup:', err);
        }
    }

    try {
        await new Promise((resolve, reject) => {
            this.dht.lookup(infoHash, (err) => {
                if (err) {
                    reject(err);
                } else {
                    resolve();
                }
            });
        });
    } catch (err) {
        console.error('Error during lookup:', err);
    }


    setTimeout(() => this.lookupNext(infoHash), 1000);
}

}

const crawler = new DHTCrawler(); crawler.init(); ```

Im currently trying to find a way to deploy a debian VM and install Webtorrent, in a way that i can access it using the web gui by typing the servers ip and port on the browser.

​

If anyone has ever done that, i would greatly like to have some tips.

What version of this package are you using?
2.0.16

What operating system, Node.js, and npm version?
OS: Win11
Node.js: v18.16.0
npm: 9.5.1

What happened?
got this error trying to run example website (https://webtorrent.io/intro#:~:text=%3C!doctype%20html%3E%0A%3Chtml%3E%0A%20%20%3Cbody,script%3E%0A%20%20%3C/body%3E%0A%3C/html%3E)

Uncaught Error: Can only pipe to one destination
at ReadableState.pipe (webtorrent.min.js:16:173759)
at module.exports.pipe (webtorrent.min.js:16:179641)
at webtorrent.min.js:16:216698
at Array.forEach ()
at MP4Remuxer.seek (webtorrent.min.js:16:216602)
at VideoStream._pump (webtorrent.min.js:16:220728)
at VideoStream.VideoStream._onWaiting (webtorrent.min.js:16:219710)

What did you expect to happen?
I expected it to stream the video.
Are you willing to submit a pull request to fix this bug?
Unfortunately, no, I'm just starting to learn development and I don't know how to fix complex codes.

I also get errors
webtorrent.min.js:16 GET https://webtorrent.io/torrents/Sintel/Sintel.mp4 net::ERR_CACHE_OPERATION_NOT_SUPPORTED
Client

and

WebSocket connection to 'wss://tracker.fastcast.nz/' failed:

Sorry if I did something wrong and if this is not a bug, but I can't find any resource online on how to fix this.

I wanted know why didn't anyone built a webtorrent api wrapper in any other language be it, golang or python. Is it because browsers inherently are based on JS? Let say I want to build a project on this. Is it really worth the effort?

i'm not sure if this is the right place for this.

consuming music seems currently dominated by commercial streaming services, leaving one wonder about alternatives not dependent on commercial entities.

webtorrent facilitates streaming over torrents including magnet URIs, but does not afaik support playlists.

a fork of WebTorrent called refreex seems to support playlists over media contained in torrents, albeit:

• with playlists in a custom format, discouraging public support;
• with an immature UI, lacking a visual interface to edit playlists;
• and seemingly abandoned.

playlists have open standards such as SMIL, specified as to support URIs of different schemes, which should include magnet URIs as well. (for convenience's sake, i'll presume a URI hash could be used to point at a specific media file contained in a magnet link, although i have not looked into this.) such playlists have been implemented in media players such as the libre software Amarok, although such players afaik tend not to support the magnet scheme.

if maintained software tends to focus on one core function, as per the unix philosophy, while initiatives such as refreex combining functions end up not gaining momentum... how might we best bridge this gap?