Bitcoin Forum
November 22, 2026, 12:59:37 AM *
News: Latest Bitcoin Core release: 32.1 [Torrent]
 
   Home   Help Search Login Register More  
Pages: « 1 ... 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 [704]
  Print  
Author Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it  (Read 418800 times)
fecell
Jr. Member
*
Offline

Activity: 205
Merit: 2


View Profile
November 10, 2026, 08:24:01 AM
 #14061

Soon I will publish code that clearly demonstrates the kangaroo algorithm.
Baby-Step Giant-Step (BSGS):
Solves g^x = h in a cyclic group of order n, or x in an interval of length N.

Precompute baby steps g^j for j = 0..m-1 in a hash table.

Compute giant steps h * (g^-m)^i and look for a match.

Time O(sqrt(N)), memory O(sqrt(N)).

Deterministic; works for any generic group.

Pollard's Kangaroo (Lambda) Algorithm:
Solves g^x = h when x is known to lie in an interval [a,b].

Uses a tame kangaroo starting at g^b and a wild kangaroo starting at h.

Both jump by pseudorandom exponents; a collision reveals x.

Expected time O(sqrt(b-a)), memory O(1).

Probabilistic; needs a bounded interval.

Key difference: BSGS is deterministic and memory-heavy; Kangaroo is probabilistic, constant-memory, and interval-based.

MITM Algorithm:
Large and small circle reduce range constantly till solution not found. (not public available, get all free RAM/VRAM, tested only with known PK, so far, MITM has not been used to solve any truly complex puzzle, need powerful hardware)
fecell
Jr. Member
*
Offline

Activity: 205
Merit: 2


View Profile
November 10, 2026, 08:41:36 AM
 #14062

Code:
==========* FOUND!=========
[Launch 58] Total:93, 415, 538, 688 koys | Rate: 377.25 M keys/s | Elapsed: 4.3s

Code:
Device Name:                NVIDIA GeForce GTX 1650 Ti
FOUND VERIFIED SOLUTION:
PRIVATE KEY:      1,003,651,412,950
SEARCH TIME:      00:00:02
probes_done:      536870912 (0.0977% of sweep)
Roll Eyes
demonarcher360
Newbie
*
Offline

Activity: 12
Merit: 0


View Profile
November 10, 2026, 11:46:23 AM
 #14063

Soon I will publish code that clearly demonstrates the kangaroo algorithm.
Baby-Step Giant-Step (BSGS):
Solves g^x = h in a cyclic group of order n, or x in an interval of length N.

Precompute baby steps g^j for j = 0..m-1 in a hash table.

Compute giant steps h * (g^-m)^i and look for a match.

Time O(sqrt(N)), memory O(sqrt(N)).

Deterministic; works for any generic group.

Pollard's Kangaroo (Lambda) Algorithm:
Solves g^x = h when x is known to lie in an interval [a,b].

Uses a tame kangaroo starting at g^b and a wild kangaroo starting at h.

Both jump by pseudorandom exponents; a collision reveals x.

Expected time O(sqrt(b-a)), memory O(1).

Probabilistic; needs a bounded interval.

Key difference: BSGS is deterministic and memory-heavy; Kangaroo is probabilistic, constant-memory, and interval-based.

MITM Algorithm:
Large and small circle reduce range constantly till solution not found. (not public available, get all free RAM/VRAM, tested only with known PK, so far, MITM has not been used to solve any truly complex puzzle, need powerful hardware)





Only with the key exposed—these two algorithms, correct?
Efim_Wr
Newbie
*
Offline

Activity: 11
Merit: 0


View Profile WWW
November 10, 2026, 01:44:33 PM
 #14064

Hello everyone,

I'd like to share an open-source tool I developed for visualizing and studying the Pollard's Kangaroo algorithm on the secp256k1 elliptic curve. This isn't just another "key cracking" script — it's an educational project designed to show exactly how the "Tame" and "Wild" kangaroos jump across the curve, converge, and eventually collide in real-time.
https://github.com/Fantom-C/web-pollard-kangaroo
Algorithm parameters: K (jump table size), dpBit (Distinguished Points filter to save memory), MAX_ITER, and jump direction (R/L). Auto-calculated optimal values are provided.
kTimesG
Sr. Member
****
Offline

Activity: 1008
Merit: 277


View Profile
November 10, 2026, 01:59:26 PM
Merited by Cricktor (1)
 #14065

Pollard's Kangaroo (Lambda) Algorithm:
Solves g^x = h when x is known to lie in an interval [a,b].

Uses a tame kangaroo starting at g^b and a wild kangaroo starting at h.

The improved versions start from (a+b)/2 for obvious reasons. Oorschot's paper had a terrible typo about that "b" that contradicts the analysis just one page after. Most people later reproduced the typo, because academic papers need to confirm flaws. Waiting for the troll agents now.

Efim_Wr
Newbie
*
Offline

Activity: 11
Merit: 0


View Profile WWW
November 11, 2026, 09:39:25 AM
 #14066

I’m planning to release a tool with a graphical user interface for the SOTA and SOTA2 methods, featuring flexible settings for the "kangaroos" and their behavior, with GPU-accelerated processing. Do you think there’s a need for a tool like this?
cctv5go
Newbie
*
Offline

Activity: 65
Merit: 0


View Profile
November 12, 2026, 08:49:54 AM
 #14067

Code:
==========* FOUND!=========
[Launch 58] Total:93, 415, 538, 688 koys | Rate: 377.25 M keys/s | Elapsed: 4.3s

Code:
Device Name:                NVIDIA GeForce GTX 1650 Ti
FOUND VERIFIED SOLUTION:
PRIVATE KEY:      1,003,651,412,950
SEARCH TIME:      00:00:02
probes_done:      536870912 (0.0977% of sweep)
Roll Eyes
The scanning method is different, and so are the results. Bro, you did a good job.
Bitcoin71
Newbie
*
Offline

Activity: 7
Merit: 1


View Profile
November 12, 2026, 09:22:11 AM
 #14068

Did anyone considered converting that private keys to RAW micro timestamp? From the exact time of the transaction You might get something here!
brainless
Member
**
Offline

Activity: 510
Merit: 46


View Profile
November 17, 2026, 01:09:33 PM
 #14069

Who have ability to check 1 million pubkeys in 100 bit range, with kangaroo +database
And how much time it will take?

13sXkWqtivcMtNGQpskD78iqsgVy9hcHLF
bankeroft
Newbie
*
Offline

Activity: 26
Merit: 0


View Profile
November 17, 2026, 10:12:49 PM
 #14070

Who have ability to check 1 million pubkeys in 100 bit range, with kangaroo +database
And how much time it will take?

Using Kangaroo + existing databases to "scan" 1 million 100-bit public keys one by one is theoretically possible but practically infeasible, with time measured in thousands of years or more  Cheesy Shocked
Efim_Wr
Newbie
*
Offline

Activity: 11
Merit: 0


View Profile WWW
November 18, 2026, 10:48:24 AM
 #14071

Who have ability to check 1 million pubkeys in 100 bit range, with kangaroo +database
And how much time it will take?
On a Tesla V100, searching for a single key within a given range takes about a day; consequently, searching for 1 million keys on the same graphics card would require 1 million days—though if the card proves to be faster, the result could be obtained sooner.
kTimesG
Sr. Member
****
Offline

Activity: 1008
Merit: 277


View Profile
November 18, 2026, 02:48:32 PM
 #14072

Who have ability to check 1 million pubkeys in 100 bit range, with kangaroo +database
And how much time it will take?

Assuming all keys are actually in the same interval:

First key found after ~2**50 steps, more or less.
Second key found faster.
...
The millionth key found after around 2**33 steps, so basically instantly.

Total cost: around a few million dollars in compute time, where each subsequent key costs less than the previous one.

Totally feasible in matters of days if you have the bucks. It's funny to see opinions of this task taking millions of years, that is correct if you run things on toasters, and it would have the exact same total cost anyway.

Liquid_One
Newbie
*
Offline

Activity: 2
Merit: 0


View Profile
November 18, 2026, 08:56:51 PM
 #14073

   I dunno why this puzzle still gets some users' attention. It just ain't mathematically profitable at the current difficulty. Maybe it's 'cause of the amount of money. If I was the creator, I'd just release the private keys for all the rest of 'em, at least from 76 on, and leave 4 up to the luck of the hashes, if in their head they also wanna test some hash vulnerability.
fecell
Jr. Member
*
Offline

Activity: 205
Merit: 2


View Profile
November 19, 2026, 09:35:33 AM
 #14074

I dunno why this puzzle still gets some users' attention. It just ain't mathematically profitable at the current difficulty. Maybe it's 'cause of the amount of money. If I was the creator, I'd just release the private keys for all the rest of 'em, at least from 76 on, and leave 4 up to the luck of the hashes, if in their head they also wanna test some hash vulnerability.
The essence of the experiment is to understand just how powerful modern technologies - algorithms, hardware, scalability, and so on - truly are.
linuzm0b
Newbie
*
Offline

Activity: 2
Merit: 0


View Profile
November 19, 2026, 10:33:55 AM
 #14075

Someone knows the original wallet software or generator implementation or any BIP32 derivation information (xpub, chain code or derivation path) ?
fecell
Jr. Member
*
Offline

Activity: 205
Merit: 2


View Profile
November 19, 2026, 12:30:05 PM
 #14076

point (scalar) 28 very interesting at secp256k1.

It is incomprehensible how two points ended up on the same straight line as the final point.

Code:
"""Гpaфичecкaя визyaлизaция тoчeк secp256k1: (2^i)G и cкaляpнoгo yмнoжeния P = k·G."""

import math
import random
import tkinter as tk
from tkinter import ttk, messagebox

import matplotlib

matplotlib.use("TkAgg")
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
from matplotlib.figure import Figure

# Пapaмeтpы secp256k1
P_CURVE = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
A_CURVE = 0
B_CURVE = 7
GX = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
GY = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8
N_ORDER = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

# Цвeтa гpaфикa
COLOR_G = "red"         # тoчкa G — кpacнaя звёздoчкa
COLOR_POW = "tab:blue"  # тoчки (2^i)G
COLOR_P = "tab:green"   # тoчкa P
COLOR_LINE = "gray"     # лyчи oт P к тoчкaм-cлaгaeмым


class ECPoint:
    """Toчкa кpивoй в aффинныx кoopдинaтax; бecкoнeчнocть зaдaётcя (None, None)."""

    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def is_infinity(self):
        return self.x is None

    def __eq__(self, other):
        if not isinstance(other, ECPoint):
            return NotImplemented
        return self.x == other.x and self.y == other.y

    def __repr__(self):
        if self.is_infinity():
            return "ECPoint(infinity)"
        return f"ECPoint({hex(self.x)}, {hex(self.y)})"


INF = ECPoint(None, None)
G = ECPoint(GX, GY)


def is_on_curve(point):
    """Пpoвepкa пpинaдлeжнocти тoчки кpивoй y^2 = x^3 + 7 (mod p)."""
    if point.is_infinity():
        return True
    return (point.y ** 2 - (point.x ** 3 + A_CURVE * point.x + B_CURVE)) % P_CURVE == 0


def inv_mod(k, mod=P_CURVE):
    """Oбpaтный элeмeнт пo мoдyлю."""
    return pow(k % mod, -1, mod)


def point_add(p1, p2):
    """Cлoжeниe тoчeк кpивoй."""
    if p1.is_infinity():
        return p2
    if p2.is_infinity():
        return p1

    x1, y1 = p1.x, p1.y
    x2, y2 = p2.x, p2.y

    if x1 == x2:
        if (y1 - y2) % P_CURVE == 0:
            # Удвoeниe (P == P); cлyчaй y == 0 дaёт тoчкy нa бecкoнeчнocти
            if y1 == 0:
                return INF
            lam = (3 * x1 * x1 + A_CURVE) * inv_mod(2 * y1) % P_CURVE
        else:
            # P1 == -P2
            return INF
    else:
        lam = (y2 - y1) * inv_mod(x2 - x1) % P_CURVE

    x3 = (lam * lam - x1 - x2) % P_CURVE
    y3 = (lam * (x1 - x3) - y1) % P_CURVE
    return ECPoint(x3, y3)


def point_double(point):
    return point_add(point, point)


def parse_int(text):
    """Paзбop цeлoгo в дecятичнoм или шecтнaдцaтepичнoм (0x...) видe."""
    text = text.strip().replace("_", "").replace(" ", "")
    if not text:
        raise ValueError("пycтoe знaчeниe")
    return int(text, 0)


class NavigationToolbarNoCoords(NavigationToolbar2Tk):
    """Tyлбap matplotlib бeз вывoдa кoopдинaт кypcopa "(x, y) = ..."."""

    def set_message(self, s):
        pass


class Secp256k1PlotApp:
    def __init__(self, root):
        self.root = root
        root.title("secp256k1: тoчки (2^i)G и cкaляp P")
        root.geometry("1000x780")
        root.minsize(700, 500)

        self.scalar_var = tk.StringVar(value="1")
        self.bits_var = tk.StringVar(value="16")
        self._anim_running = False
        self._anim_job = None

        self._build_ui()
        self.plot_current()
        self.root.protocol("WM_DELETE_WINDOW", self.on_close)

    def on_close(self):
        self.on_stop()
        self.root.destroy()

    def _build_ui(self):
        controls = ttk.Frame(self.root, padding=8)
        controls.pack(side=tk.TOP, fill=tk.X)

        ttk.Label(controls, text="Cкaляp:").grid(row=0, column=0, sticky="w")
        ttk.Entry(controls, textvariable=self.scalar_var, width=50).grid(
            row=0, column=1, sticky="we", padx=(4, 12)
        )

        ttk.Label(controls, text="Битнocть:").grid(row=0, column=2, sticky="w")
        ttk.Entry(controls, textvariable=self.bits_var, width=8).grid(
            row=0, column=3, sticky="w", padx=(4, 12)
        )

        ttk.Button(controls, text="Random", command=self.on_random).grid(row=0, column=4, padx=(0, 6))
        ttk.Button(controls, text="Пocтpoить", command=self.plot_current).grid(row=0, column=5)

        self.start_btn = ttk.Button(controls, text="Start", command=self.on_start)
        self.start_btn.grid(row=0, column=6, padx=(12, 0))
        self.stop_btn = ttk.Button(controls, text="Stop", command=self.on_stop, state=tk.DISABLED)
        self.stop_btn.grid(row=0, column=7, padx=(6, 0))

        controls.columnconfigure(1, weight=1)

        fig_frame = ttk.Frame(self.root)
        fig_frame.pack(side=tk.TOP, fill=tk.BOTH, expand=True)

        self.fig = Figure(figsize=(9, 7), dpi=100)
        self.ax = self.fig.add_subplot(111)
        self.fig.subplots_adjust(left=0.04, right=0.97, top=0.96, bottom=0.05)

        self.canvas = FigureCanvasTkAgg(self.fig, master=fig_frame)
        self.toolbar = NavigationToolbarNoCoords(self.canvas, fig_frame, pack_toolbar=False)

        # Tyлбap и cтpoкa cyммы yпaкoвывaютcя ДO canvas, чтoбы canvas
        # (зaпpaшивaющий 900x700) нe oтнял вcё пpocтpaнcтвo oкнa.
        self.toolbar.pack(side=tk.BOTTOM, fill=tk.X)

        self.sum_var = tk.StringVar(value="")
        self.sum_label = ttk.Label(
            fig_frame,
            textvariable=self.sum_var,
            padding=(8, 6),
            font=("TkDefaultFont", 10, "bold"),
        )
        self.sum_label.pack(side=tk.BOTTOM, fill=tk.X)

        self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)

        self.root.bind("<Return>", lambda _e: self.plot_current())

    def on_random(self):
        try:
            bits = parse_int(self.bits_var.get())
        except ValueError:
            messagebox.showerror("Oшибкa", "Heкoppeктнoe знaчeниe битнocти.")
            return
        if not 1 <= bits <= 256:
            messagebox.showerror("Oшибкa", "Битнocть дoлжнa быть в диaпaзoнe 1..256.")
            return
        self.scalar_var.set(str(random.randint(2 ** (bits - 1), (2 ** bits) - 1)))
        self.plot_current()

    # --- Peжим aнимaции: cкaляp yвeличивaeтcя нa 1 кaждыe 2 ceкyнды ---

    def on_start(self):
        if self._anim_job is not None:
            return
        self._anim_running = True
        self.start_btn.config(state=tk.DISABLED)
        self.stop_btn.config(state=tk.NORMAL)
        self._anim_job = self.root.after(2000, self._anim_step)

    def on_stop(self):
        self._anim_running = False
        if self._anim_job is not None:
            self.root.after_cancel(self._anim_job)
            self._anim_job = None
        self.start_btn.config(state=tk.NORMAL)
        self.stop_btn.config(state=tk.DISABLED)

    def _anim_step(self):
        self._anim_job = None
        if not self._anim_running:
            return
        try:
            scalar = parse_int(self.scalar_var.get())
        except ValueError:
            # Heкoppeктный ввoд — пpoпycкaeм шaг, нe мeшaя aнимaции
            self._anim_job = self.root.after(2000, self._anim_step)
            return
        # Пo дocтижeнии n-1 cкaляp пepeзaпycкaeтcя c 1
        scalar = 1 if scalar >= N_ORDER - 1 else scalar + 1
        self.scalar_var.set(str(scalar))
        self.plot_current()
        self._anim_job = self.root.after(500, self._anim_step)

    def plot_current(self):
        try:
            scalar = parse_int(self.scalar_var.get())
        except ValueError:
            messagebox.showerror("Oшибкa", "Heкoppeктнoe знaчeниe cкaляpa.")
            return
        if not 0 < scalar < N_ORDER:
            messagebox.showerror("Oшибкa", "Cкaляp дoлжeн быть в диaпaзoнe 1..n-1.")
            return

        # Oдин пpoxoд: cтpoим тoчки (2^i)G и oднoвpeмeннo P = cyммa cлaгaeмыx
        # пo eдиничным битaм cкaляpa.
        pow_points = []
        components = []  # индeкcы i, вxoдящиe в бинapнoe paзлoжeниe cкaляpa
        p_point = INF
        cur = G
        tmp = scalar
        while tmp:
            if tmp & 1:
                components.append(len(pow_points))
                p_point = point_add(p_point, cur)
            pow_points.append(cur)
            cur = point_double(cur)
            tmp >>= 1

        # Cyммa длин вcex лyчeй (кoopдинaты нopмиpoвaны нa p, квaдpaт 0..1)
        px_n, py_n = p_point.x / P_CURVE, p_point.y / P_CURVE
        total_len = 0.0
        for idx in components:
            q = pow_points[idx]
            total_len += math.hypot(px_n - q.x / P_CURVE, py_n - q.y / P_CURVE)
        self.sum_var.set(f"Cyммa длин лyчeй: {total_len:.6f}")

        self._draw_plot(pow_points, components, p_point)

    def _draw_plot(self, pow_points, components, p_point):
        ax = self.ax
        ax.clear()

        # Toчки (2^i)G; пepвaя — G, выдeляeтcя кpacнoй звёздoчкoй.
        # Кoopдинaты нopмиpyютcя нa p, чтoбы гpaфик вceгдa зaнимaл квaдpaт 0..1.
        xs, ys = [], []
        for idx, pt in enumerate(pow_points):
            x, y = pt.x / P_CURVE, pt.y / P_CURVE
            if idx == 0:
                ax.scatter([x], [y], s=140, marker="*", color=COLOR_G, zorder=5)
                ax.annotate(
                    str(idx + 1),
                    (x, y),
                    textcoords="offset points",
                    xytext=(6, 6),
                    fontsize=9,
                    fontweight="bold",
                    color=COLOR_G,
                )
            else:
                xs.append(x)
                ys.append(y)
                ax.annotate(
                    str(idx + 1),
                    (x, y),
                    textcoords="offset points",
                    xytext=(5, 4),
                    fontsize=8,
                    color=COLOR_POW,
                )
        if xs:
            ax.scatter(xs, ys, s=40, marker="o", color=COLOR_POW, zorder=4)

        # Toчкa P (бeз пoдпиcи) и лyчи к тoчкaм-cлaгaeмым
        if not p_point.is_infinity():
            px, py = p_point.x / P_CURVE, p_point.y / P_CURVE
            for idx in components:
                q = pow_points[idx]
                ax.plot(
                    [px, q.x / P_CURVE],
                    [py, q.y / P_CURVE],
                    color=COLOR_LINE,
                    linewidth=1.0,
                    alpha=0.6,
                    zorder=3,
                )
            ax.scatter([px], [py], s=40, marker="o", color=COLOR_P, zorder=6)

        # Фикcиpoвaнный мacштaб 0..1 пo oбeим ocям, бeз дeлeний и пoдпиceй
        ax.set_xlim(0, 1)
        ax.set_ylim(0, 1)
        ax.set_autoscale_on(False)
        ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)
        ax.grid(False)

        self.canvas.draw_idle()


def main():
    if not is_on_curve(G):
        raise RuntimeError("Гeнepaтop G нe лeжит нa кpивoй secp256k1 — пpoвepьтe пapaмeтpы.")

    root = tk.Tk()
    style = ttk.Style()
    if "clam" in style.theme_names():
        style.theme_use("clam")
    Secp256k1PlotApp(root)
    root.mainloop()


if __name__ == "__main__":
    main()
Bitcoin71
Newbie
*
Offline

Activity: 7
Merit: 1


View Profile
November 21, 2026, 01:43:13 PM
 #14077

Is this range fully scanned anyone has data 410000000000000000:41ffffffffffffffff
Thanks for anyone is answering in advance.
SecretAdmirere
Jr. Member
*
Offline

Activity: 35
Merit: 2


View Profile
Today at 12:23:15 AM
 #14078

CUDACyclone-SecretAdmirere: a Windows CUDA solver for the Bitcoin puzzle transaction

Topic: https://bitcointalk.org/index.php?topic=5599906.msg67347221#msg67347221

Hello everyone,

I rewrote a version of a CUDA puzzle solver, and I'm releasing it as open source (GPLv3).

Features
  • Compressed P2PKH addresses only
  • Windows 10/11 x64 only, NVIDIA RTX 30xx, 40xx and 50xx GPUs only
  • Randomized search (not a sequential scan)
  • Modular design with easy-to-follow logic. The GPU math (CUDAMath.cuh) and hashing (CUDAHash.cuh) are separate headers. If you don't like my search logic, you are welcome to take these two files, or parts of the code, and use them in your own project under the GPLv3 license. The optimized math, hashing and kernels are where the speed increase on GPUs comes from.

Speed
I measured about +27% and +37% over the reference figure from btcpuzzle.info/benchmark on an RTX 3070 Ti and 3080 Ti (real kernel speed, not Speed With Included Overhead). I have only tested those two cards so far. The other values in the README table are estimates (27% applied to the reference figure), and I will replace them as people post results. Please post your GPU, --grid and speed below, and make sure you use NVIDIA's official reference TDP for the card you benchmark.

RTX 5090 - 10,236 Mkeys/s (10.2B key/s) Estimated
RTX 4090 - 7,569 Mkeys/s (7.5B key/s) Estimated
RTX 3090 Ti - 3,581 Mkeys/s (3.5B key/s) Estimated

Notes
  • It is a probabilistic search: there is no guaranteed coverage and no guaranteed time to find a key.
  • --pubkey mode is intended for benchmarking only.
  • The precompiled .exe may be flagged by some antivirus programs. The full source is in the repo, so you can build it yourself with Visual Studio 2022 and the latest CUDA Toolkit.

Download / source
GitHub: CUDACyclone-SecretAdmirere

Credits
Inspired by Dookoo2's CUDACyclone. Includes parts derived from Jean Luc PONS' VanitySearch and RetiredCoder's RCKangaroo (both GPLv3).

Donations
My PC was recently destroyed by a PSU failure and I'm saving for used parts to keep developing (about $2,000 needed). Any help is appreciated:
Code:
bc1q67nxvkge5ylq7fsvkhujmpvnut2a3964jqn4el

Use at your own risk.

Feedback, bug reports, suggestions, thoughts are welcome.

bc1q67nxvkge5ylq7fsvkhujmpvnut2a3964jqn4el
Pages: « 1 ... 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 [704]
  Print  
 
Jump to:  

Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!