The game window is 500x500 pixels with a black background. Balloons have a random radius of between 20 and 40 pixels. You are free to choose the method to create the balloons - either geometrically create them or use opensource images. There is a 50% chance that a balloon is red and a 50% chance that is is green. Balloons start with their centre at a random x position between their radius and the width of the window minus the radius. Balloons start with a y position of minus the radius (i.e. off the top of the screen). The speed of the game is determined by a variable speed calculated as follows: speed=(time since game has started in seconds)/10.0+1.0; Balloons have a constant random y velocity between 0 and 100 + (speed * 50) pixels per second The time (in seconds) between balloons appearing is: (a random double precision number between 0 and 2)/speed

Based on the given specifications, here is a sample implementation in Java using JavaFX library:

import javafx.animation.AnimationTimer;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.image.Image;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;
import javafx.stage.Stage;

import java.util.Random;

public class BalloonGame extends Application {

    private static final int WINDOW_WIDTH = 500;
    private static final int WINDOW_HEIGHT = 500;
    private static final Color BACKGROUND_COLOR = Color.BLACK;
    private static final int MIN_BALLOON_RADIUS = 20;
    private static final int MAX_BALLOON_RADIUS = 40;
    private static final double BALLOON_APPEAR_TIME = 2.0;
    private static final double INITIAL_SPEED = 1.0;
    private static final int MAX_Y_VELOCITY = 100;
    private static final Random RANDOM = new Random();

    private Pane gamePane;
    private double lastBalloonTime = 0.0;
    private double speed = INITIAL_SPEED;

    @Override
    public void start(Stage primaryStage) throws Exception {
        gamePane = new Pane();
        gamePane.setPrefSize(WINDOW_WIDTH, WINDOW_HEIGHT);
        gamePane.setStyle("-fx-background-color: black;");

        AnimationTimer gameLoop = new AnimationTimer() {
            @Override
            public void handle(long now) {
                update(now);
            }
        };
        gameLoop.start();

        Scene scene = new Scene(gamePane, WINDOW_WIDTH, WINDOW_HEIGHT);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    private void update(long now) {
        double elapsedTime = (now - lastBalloonTime) / 1_000_000_000.0;
        if (elapsedTime >= BALLOON_APPEAR_TIME / speed) {
            createBalloon();
            lastBalloonTime = now;
        }

        for (Circle balloon : gamePane.getChildren()) {
            double yVelocity = MAX_Y_VELOCITY + speed * 50;
            double y = balloon.getCenterY() + yVelocity * elapsedTime;
            balloon.setCenterY(y);

            if (y - balloon.getRadius() > WINDOW_HEIGHT) {
                gamePane.getChildren().remove(balloon);
            }
        }

        speed = (now / 1_000_000_000.0) / 10.0 + INITIAL_SPEED;
    }

    private void createBalloon() {
        int radius = RANDOM.nextInt(MAX_BALLOON_RADIUS - MIN_BALLOON_RADIUS + 1) + MIN_BALLOON_RADIUS;
        double x = RANDOM.nextInt(WINDOW_WIDTH - radius * 2) + radius;
        double y = -radius;

        Color color = RANDOM.nextBoolean() ? Color.RED : Color.GREEN;
        Circle balloon = new Circle(x, y, radius, color);
        gamePane.getChildren().add(balloon);
    }

    public static void main(String[] args) {
        launch(args);
    }
}

This implementation uses JavaFX to create the game window and handle the animation loop. It creates balloons as Circle shapes with random radius, position, and color. The balloons move down the screen with a constant y velocity that increases with the game speed. The game speed is determined by the time since the game started, and affects the time between balloons appearing and the y velocity of the balloons.