This repo contains the full precision source code, in "safe tensors" format to generate GGUFs, GPTQ, EXL2, AWQ, HQQ and other formats. The source code can also be used directly.
This model contains Brainstorm 20x, combined with ertghiu256's 4B General / Coder (instruct model):
https://huggingface.co/ertghiu256/qwen3-4b-code-reasoning
Information on the 4B model below, followed by Brainstorm 20x adapter (by DavidAU) and then a complete help section for running LLM / AI models.
The Brainstorm adapter improves code generation, and unique code solving abilities.
This model requires:
Settings used for testing (suggested):
FOR CODING:
Higher temps: .6 to .9 (even over 1) work better for more complex coding / especially with more restrictions.
This model will respond well to both detailed instructions and step by step refinement and additions to code.
As this is an instruct model, it will also benefit from a detailed system prompt too.
For simpler coding problems, lower quants will work well; but for complex/multi-step problem solving suggest Q6 or Q8.
Generated by reveai.org
A small Qwen 3 4 billion parameter model trained on nvidia/OpenCodeReasoning for coding tasks. For Coding, it is recommended to be in thinking mode.
> Write me a snake game in python. Ensure all keybinding (WASD) work properly and all mechanics from the original snake game works. /think
<think>
Okay, I need to write a Snake game in Python where all the keybindings (WASD) work properly and all the original mechanics are included. Let me think about how to approach this.
First, I remember that the classic Snake game works by having a snake move in a direction, grow when it eats food, and die if it hits the wall or itself. The keybindings should allow the snake to change direction using W, A, S, D. But I need to make sure that the movement is smooth and that the snake can't reverse direction immediately, which might cause it to collide with itself right away.
So, the plan is to use the pygame library because it's commonly used for game development in Python. I'll need to initialize the game window, set up the display, handle the game loop, manage the snake's movement, check for collisions, and handle the food.
Let me outline the steps:
Import necessary modules: Pygame, sys, random for generating food, time for delay.
Initialize Pygame: Set up the display, clock, fonts, etc.
Define constants: Screen size, grid size (like 20x20), snake speed, colors.
Create the Snake class: Each segment of the snake. The snake moves in a direction, and each segment follows the previous one.
Create the Food class: Randomly placed on the screen, and when eaten, the snake grows.
Game loop:
Handle events (WASD for direction).
Move the snake.
Check for collisions (walls or self).
Check if food is eaten, then increase length.
Update the display.
Control the game speed with a clock.
Handle keybindings: Make sure that the snake can't reverse direction. So, if the current direction is right, the next can't be left, and so on.
Wait, but in the original Snake game, ...(Too long)
</think>
Here's a complete implementation of the **Snake Game** using the `pygame` library. The game allows the player to control the snake using the **WASD keys**, and the snake moves in the direction of the last key pressed. The game ends when the snake collides with the wall or itself, and the snake grows by one segment each time it eats the food.
---
### ✅ Features:
- **WASD Controls**:
- `W` → Up
- `A` → Left
- `S` → Down
- `D` → Right
- **Food Generation**:
- Randomly placed on a 32×24 grid (640×480 pixels).
- **Game Over**:
- Ends when the snake hits the wall or itself.
- **Speed Control**:
- Set with `clock.tick(10)` to control the game speed.
---
### 🧠 How It Works:
1. The snake starts with 3 segments.
2. The player uses `W`, `A`, `S`, `D` to change the direction.
3. The snake moves in the current direction, growing if it eats the food.
4. When the snake collides with the wall or itself, the game ends.
---
### 📦 Code Implementation
```python
import pygame
import sys
import random
# Initialize Pygame
pygame.init()
# Game settings
SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
BLOCK_SIZE = 20
GRID_WIDTH = SCREEN_WIDTH // BLOCK_SIZE
GRID_HEIGHT = SCREEN_HEIGHT // BLOCK_SIZE
# Colors
BLACK = (0, 0, 0)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
# Initialize screen
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Snake Game")
# Clock
clock = pygame.time.Clock()
# Snake
snake_segments = [(3, 3), (2, 3), (1, 3)]
direction = (1, 0) # Start moving right
# Food
def generate_food():
while True:
x = random.randint(0, GRID_WIDTH - 1)
y = random.randint(0, GRID_HEIGHT - 1)
if (x, y) not in snake_segments:
return (x, y)
food = generate_food()
# Game loop
running = True
ate_food = False
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_w:
direction = (0, -1)
elif event.key == pygame.K_a:
direction = (-1, 0)
elif event.key == pygame.K_s:
direction = (0, 1)
elif event.key == pygame.K_d:
direction = (1, 0)
# Move the snake
new_head = (snake_segments[0][0] + direction[0], snake_segments[0][1] + direction[1])
snake_segments.insert(0, new_head)
if not ate_food:
snake_segments.pop()
ate_food = False
# Check for collisions
if (new_head[0] < 0 or new_head[0] >= GRID_WIDTH or
new_head[1] < 0 or new_head[1] >= GRID_HEIGHT):
pygame.quit()
sys.exit()
if new_head in snake_segments[1:]:
pygame.quit()
sys.exit()
# Check if food is eaten
if new_head == food:
food = generate_food()
ate_food = True
# Draw everything
screen.fill(BLACK)
for segment in snake_segments:
pygame.draw.rect(screen, GREEN, (segment[0] * BLOCK_SIZE, segment[1] * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE))
pygame.draw.rect(screen, RED, (food[0] * BLOCK_SIZE, food[1] * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE))
pygame.display.flip()
# Control the game speed
clock.tick(10)
pygame.quit()
sys.exit()
```⠀
---
### 🧪 How to Run:
1. Install `pygame` using pip:
`pip install pygame`
2. Save the code in a file, e.g., `snake_game.py`.
3. Run the file using Python:
`python snake_game.py`
---
### 🚀 Tips:
- The game is fast-paced. You can slow it down by increasing the value in `clock.tick(10)` (e.g., `clock.tick(15)`).
- The snake starts in the middle of the screen, and the food is placed randomly.
Enjoy playing the **Snake Game**! 🐍🎮
See more here:
https://huggingface.co/ertghiu256/qwen3-4b-code-reasoning
Brainstorm 20x
The BRAINSTORM process was developed by David_AU.
Some of the core principals behind this process are discussed in this scientific paper : Progressive LLaMA with Block Expansion .
However I went in a completely different direction from what was outlined in this paper.
What is "Brainstorm" ?
The reasoning center of an LLM is taken apart, reassembled, and expanded.
In this case for this model: 20 times
Then these centers are individually calibrated. These "centers" also interact with each other. This introduces subtle changes into the reasoning process. The calibrations further adjust - dial up or down - these "changes" further. The number of centers (5x,10x etc) allow more "tuning points" to further customize how the model reasons so to speak.
The core aim of this process is to increase the model's detail, concept and connection to the "world", general concept connections, prose quality and prose length without affecting instruction following.
This will also enhance any creative use case(s) of any kind, including "brainstorming", creative art form(s) and like case uses.
Here are some of the enhancements this process brings to the model's performance:
Other "lab" observations:
The process to modify the model occurs at the root level - source files level. The model can quanted as a GGUF, EXL2, AWQ etc etc.
For more information / other Qwen/Mistral Coders / additional settings see:
[ https://huggingface.co/DavidAU/Qwen2.5-MOE-2x-4x-6x-8x__7B__Power-CODER__19B-30B-42B-53B-gguf ]
CHANGE THE NUMBER OF ACTIVE EXPERTS:
See this document:
https://huggingface.co/DavidAU/How-To-Set-and-Manage-MOE-Mix-of-Experts-Model-Activation-of-Experts
Settings: CHAT / ROLEPLAY and/or SMOOTHER operation of this model:
In "KoboldCpp" or "oobabooga/text-generation-webui" or "Silly Tavern" ;
Set the "Smoothing_factor" to 1.5
: in KoboldCpp -> Settings->Samplers->Advanced-> "Smooth_F"
: in text-generation-webui -> parameters -> lower right.
: In Silly Tavern this is called: "Smoothing"
NOTE: For "text-generation-webui"
-> if using GGUFs you need to use "llama_HF" (which involves downloading some config files from the SOURCE version of this model)
Source versions (and config files) of my models are here:
OTHER OPTIONS:
Increase rep pen to 1.1 to 1.15 (you don't need to do this if you use "smoothing_factor")
If the interface/program you are using to run AI MODELS supports "Quadratic Sampling" ("smoothing") just make the adjustment as noted.
Highest Quality Settings / Optimal Operation Guide / Parameters and Samplers
This a "Class 1" model:
For all settings used for this model (including specifics for its "class"), including example generation(s) and for advanced settings guide (which many times addresses any model issue(s)), including methods to improve model performance for all use case(s) as well as chat, roleplay and other use case(s) please see:
You can see all parameters used for generation, in addition to advanced parameters and samplers to get the most out of this model here: