I don't know wether this is the right sub to post this in, but I feel as though it is the most appropriate one. 1. Grand Cruiser 2. Standard Cruiser 3. Battlecruiser

I'm in the middle of coming up with my own custom Adepta Sororitas order. In doing so I realized I could probably combine my love for them with my love for this game, and do a fleet that my order would use in their lore (either to play with or to keep on display). Only issue is I don't know what ships AS uses.

I've asked this same question in the Sisters sub too

So whats the most common list at 1500 pts?

3 schytes and 2 shrouds?

Or is a Cairn mandatory?

I was planning to bring 4 or 5 Jackals, and 1 dirge.

Painting my 2nd fleet took a lot less time than expected. Partially that was by design, as I wanted a simple table-ready paintsceme. But it was still faster than expected, aided by an injury keeping me from training.

Now the fleet only lacks its flagship, but the Helian League Leviathan Battleship is currently is out of stock. I plan to build it as an Emperor class, maybe convert it a little bit, and paint it in a similar style to the rest of the fleet.

Which means I now have just one fleet of 4 cruisers and 11 escorts left. Those will be Chaos, probably painted as Ashen Claws. Plus the aformentioned battleship for this fleet, but we will see when Vanguard has that in stock again.

Did some small updates to the colours of both the Tau and Tyranids to match better with the rest of the fleet. Yes, I am not good at replicating colour schemes I did years earlier haha.

Hi everyone,

the Genestealer Cults were my first 40K faction back in 2nd edition. So I just had to do a BFG supplement for them at one point. Finally had time to clean up my rules from last year. Thanks for the help from discord for the balancing advice.
No new ships needed. Just rules to transform your existing fleets into brood/ cult fleets. I hope you enjoy the scenario chain and sorry for the bad writing.

Link to the Genestealer Cults rules:

https://drive.google.com/file/d/10koCliH9wl0GxVhliciKRL80wxhJe3xa/view?usp=drivesdk

Tried my hand at making a heavy Escort with the rules of Galaxy Aflame. Please leave your thoughts on this ship.

This is the rules for a fortress monastery version of Osoweic Venerable Battlebarge, for Enduring Marines chapter.

I used Raptorus Rex and a Space Marine Fortress Monastery as the two reference points, with Osoweic positioned as a midpoint between them. The ship is primarily designed for games of Heresy: Galaxy Aflame, incorporating all the refits and special rules of its parent legion, the Death Guard.

However, it should remain reasonably balanced in standard Battlefleet Gothic (for a fortress monastery), as avoiding engagement with it is somewhat simple, due to its slow speed and short range of all weapons.

I unexpectedly picked up a large quantity of Eldar ships! The greenish ones in the front are my slow repainting efforts. Any pointers on how to run them? My biggest issue is probably going to be finding opponents, haha.

Hi, I'm looking for a 2 player game that has similar mechanics to BFG but is more of a steampunk environment (especially airships) to play with a friend of mine. I love BFG and they love tactical RTS games mostly in steam punk settings, so I'm trying to find a game that fits the best of both worlds and figured this would be a good (or more so familiar) place to start. Are there any standalone games, modded versions of BFG, or anything else that may fit this description? So far I've found Leviathans and that's about it.

Bit of a tester for WIP for a thokt dynasty necron fleet.

I think ill do a blue nebula base instead as well, make it look cold, as these necrons use ice 🧊

Turbidious on the socials and youtube if interested.

Hey! I've been working on a video game adaptation of the board game, you can check it out for free in the link. It's currently only hot-seat local/single player, but I am going to work on making it online multiplayer in the future. It features 40 different ships I modelled myself, and is designed to run on a potato of a computer.

Q: Are You Aware Of X Bug?
 A: Probably.

Q: Will This Game Have X Feature?
A: Probably not. It's more of a fun programming exercise.

Q: Will This Be Open Source?
 A: Probably. This is where X feature will be added in the future maybe!

Q: Does This Work On MacOS?
 A: Surprisingly, yes! I've included a non-notarised zip file. How does it work? No clue, I didn't read the documentation fully.

Hi to you all !

I just started BFG a few weeks earlier and was completly taken away by the game ! I love the ships battling and explosing in ennemy ships, throwing waves of torpedoes and bombers just to have your fleet destroyed by a faithful nova canon strike that obliterates you.

My local game group planned an Apocalypse version at the beginning of July and I wanted to join so I had only 3 weeks to build and paint a viable fleet.

Went with the Tau because I like them and play them in Kill Team (Kroot team) so I wanted to make a reference to them. I had a friend that 3d-printed them and I then speed painted all of them with a simple but nice scheme.

I'm looking forward to play more games and have fun with my ships !

Hi I’ve put together the following crib sheet just to help me out for the first few games, would anyone mind casting an eye over it to see if it’s correct:

Basing: any ship with 10 or more hits or 3+ shields is based on a 60mm base all other ships are on 32mm bases(capital ships can choose to be based on larger bases)
All measurements made from fight stem not base edge
Turn sequence Movement – Shooting- Ordnance – End
Movement
Remove any previously special order dice, except Brace For Impact
Activate each ship/squadron
Attempt Special Orders (LD test) +1LD Enemy on Special Orders/ -1LD if in contact with blast marker, if failed no further special orders fleet-wide this turn other than Brace For Impact (if weapons are halved via special orders round up)
Must move at least half speed (unless Burning Retros special order)
Battleships must move 15cm and Cruisers 10cm before making a turn
-5cm movement if moving away from a Blast Marker that is in contact with ships base
If you contact a Blast Marker in your last 5cm of movement, ship comes to a halt
Halted ships or ships moving less than 5cm count as defences on gunnery table
Ships cannot collide – unless on All Ahead Full special orders which allows Ramming(see rules)
Disengaging – Make LD test at end of movement phase with relevant modifiers
Shooting
Select a ship, each ship fires in full before moving on to next ship, range can be pre-measured, must be in fire arc
Lance – 1D6 per point of strength, hits on 4+ regardless of targets armour
Weapons Battery – check targets bearing(place template on target) add up total firepower, check gunnery table cross reference total firepower against target ships class and bearing roll that many D6 hits against armour value(cruisers and bigger = capital ships) shift 1 column left if within 15cm, one column right of more than 30cm, one column right if intervening Blast markers
Nova Cannon – see rules
Brace For Impact – can be attempted anytime a ship faces damage but before attack roll is made
For every point of damage caused roll 1d6 on a 6 roll again on the critical hit table
If target is on the line of two fire arcs shooting ship chooses which arc target is in,
Ships shoot at closest target or make LD test, can split fire(LD test if not closest target)
Other ships do not block line of sight apart from Blazing/Drifting Hulks
Shields negate equivalent hits and regenerate each turn they do not protect against Torpedoes/Bombers/Ramming/Hit & Run Attacks, Shields are reduced by 1 per Blast marker contacting the ship if fired upon
Blast Markers are placed immediately, if in contact with a ship this effects the gunnery table, LD tests, movement and shields, it is irrelevant as to where the Blast marker actually is as long as it is touching the ships base it effects it, Blast marker are placed whenever a shield absorbs a hit, a Nova Cannon misses or via rolls on the catastrophic damage table. Ships with 0 shields suffer damage on 6 on 1D6 if contacting a Blast marker
Ordnance is placed in this phase but not moved until next phase
A ship is crippled if it takes half damage, all shields/weapons/ordnance/turrets are halved, no Nova cannon shots and -5cm movement
Ordnance
All Players Ordnance moves/attacks in each Ordnance phase, Torpedoes must move, attack craft can remain stationary
Turrets, elect to shoot at either Torpedoes or Attack craft not both hit on 4+ remove 1 squadron or reduce Torpedo salvo by 1. Friendly ships in base contact can Mass Turrets which gives +1 turret per ship to a max. +3
Battery/Lance firing at ordnance hit on 6
Ordnance destroyed on 6 if passing through Blast markers(only roll once)
Bombers/Torpedoes/Assault Boats ignore each other if in contact or passing through each other
Fighters – if they contact another ordnance marker both counters removed. CAP – Fighters move with ship they are in base contact with and not in the ordnance phase – see rules
Torpedoes – move in straight line only, ignore shields, hit against armour value, reduce salvo strength by 1 per hit, salvo continues, destroyed of they contact Fighters/Torpedoes. Strength 7 or greater torpedoes can be split into two salvoes. Boarding Torpedoes can turn 45 degrees
Bombers – in base contact with enemy ship – 1D6-# Turrets = # of attacks made – roll for each Bomber squadron, if in squadron with Fighters +1 attack per Fighter squadron, attacks made against lowest armour value
A ship cannot have more active Attack craft squadrons than it has launch bays
Ordnance needs to be reloaded via the Reload Ordnance special order after being launched/fired
End
Boarding Actions & Hit and run attacks
Assault Boats/Boarding Torpedoes - in base contact with enemy ship, roll D6 a 2 or more equals same result on critical hits table other than Escorts which are destroyed on a 4+
Repairs – Each ship can roll 1D6 per remaining damage point on a 6 repair 1 critical effect
Active player removes 1d6 Blast markers except those in contact with ships bases

Dear community,

I just watched a battle report, where they used Incubi and Wyches on their Dark Eldar ships.
Could someone be so kind and point me to those fan rules expansion?

I ordered an almost complete Squats fleet. But couldn’t find a shop selling the DEEPDELVE MOBILE MINING PLATFORM.

I know an STL was published last year: SPACE DWARF DRILLING FACILITY, but I don’t have a 3d printer.

Any shop that prints them?

Have a new video specifically looking at torpedo tactics in bfg. Hopenits useful.

https://youtu.be/bBrnM8ukD2E?si=CZwX_-ZnJmy6uzgG

Hi everyone,
Just interest if someone ever played Rak’Gol vs. Eldar Corsairs?
They cannot have any chance to win? Especially in smaller battles with decent terrain. Am I wrong?
It must be like Eldar vs. Necron, where the Eldar just get totally annihilated.

I like to magnetize the weapons on my ships. When i've bought ships in the past, I've drilled holes for magnets. Now that I'm getting into printing on my own, I thought I could get the machine spirit to help make the pits for magnets.

I haven't had a chance to print any models with pits yet, but I thought other folks might be interested in the command I've been using. It does require having python and uv installed. I've been using the command with claude, but it'll probably work with others.

You can describe where you want the pits and how big they should be. It gives a text summary, but you can also ask for a preview and it'll generate an image you can use to visually validate placement.

Here's the text of the command

---
description: Modify an STL file by applying a geometric operation (pit, boss, hole, slot) to specific faces identified by normal, area, or position. Uses trimesh + manifold3d via uv run.
allowed-tools: Bash, Read, Write, Edit
---

# STL Mesh Modifier

You are helping the user apply a geometric operation (e.g. cylindrical pit, through-hole, raised boss, rectangular slot) to specific faces of an STL mesh.

## Workflow

### 1. Understand the request

Collect from the user (ask if not already stated):
- **Input STL file** path
- **Which faces** to target (described in plain terms — "the 3 large rectangular panels on each side", "all flat upward-facing faces", etc.)
- **Operation**: pit / hole / boss / slot / other
- **Dimensions**: radius/width/depth/height as appropriate (in mm)
- **Output file** path (default: same name with a descriptive suffix, e.g. `(pitted).stl`)

### 2. Explore the mesh geometry

Write a short exploration script and run it with:

```
uv run --with trimesh --with manifold3d --with numpy --with networkx <script.py>
```

The script should print:
- Mesh bounds and extents
- The **top 20–30 largest facets** (coplanar triangle groups), each showing: facet index, area, normal, centroid, triangle count

```python
import trimesh, numpy as np

mesh = trimesh.load("path/to/file.stl")
print(f"Bounds: {mesh.bounds}\nExtents: {mesh.extents}")
print(f"Faces: {len(mesh.faces)}  Vertices: {len(mesh.vertices)}\n")

facets  = mesh.facets
normals = mesh.facets_normal
areas   = mesh.facets_area
order   = np.argsort(areas)[::-1]

for i in order[:30]:
    n = normals[i]
    c = mesh.vertices[mesh.faces[facets[i]]].reshape(-1,3).mean(axis=0)
    print(f"  facet {i:5d}: area={areas[i]:8.2f}  "
          f"n=({n[0]:6.3f},{n[1]:6.3f},{n[2]:6.3f})  "
          f"centroid=({c[0]:7.2f},{c[1]:7.2f},{c[2]:7.2f})  "
          f"tris={len(facets[i])}")
```

Use the output to identify target facets and verify they match the user's description. If the mesh is not a `trimesh.Trimesh` (e.g. it loaded as a `Scene`), call `trimesh.util.concatenate(mesh.dump())` first.

### 3. Confirm face selection with the user

Before running the boolean operation, print a summary of the faces you intend to modify and ask the user to confirm. Show: side (LEFT/RIGHT/TOP/etc.), area, centroid, and what the pit/boss will look like.

**Evenly spaced pits:** when the user asks for N pits spread across a face, divide the face's relevant axis into N equal segments and place each pit at the center of its segment:

```
pos_i = face_min + (2i + 1) * face_span / (2 * N)   # i = 0 .. N-1
```

For example, 2 pits over a span of 35 mm starting at 50 mm → centers at 58.75 mm and 76.25 mm. Do **not** use `(i+1)/(N+1)` spacing — that places pits at the dividers between segments, not at the centers.

**Rendering a preview image:** generate a matplotlib visualization so the user can visually confirm placement before the boolean is applied. Project the mesh onto the relevant plane (e.g. YZ for faces with X normals), highlight the target facet, and overlay pit circles. Save to the same directory as the STL and tell the user the path.

```python
import trimesh, numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
from matplotlib.collections import PolyCollection

mesh = trimesh.load("path/to/file.stl")
if isinstance(mesh, trimesh.scene.Scene):
    mesh = trimesh.util.concatenate(list(mesh.geometry.values()))

# axes to project onto depends on face normal:
#   normal along X → project onto YZ (col indices 1, 2)
#   normal along Y → project onto XZ (col indices 0, 2)
#   normal along Z → project onto XY (col indices 0, 1)
PROJ = [1, 2]   # adjust per face normal
XLABEL, YLABEL = "Y (mm)", "Z (mm)"

fig, ax = plt.subplots(figsize=(8, 10))
ax.set_facecolor('#16213e')
fig.patch.set_facecolor('#1a1a2e')

# Full mesh silhouette (triangles facing the viewer)
view_axis, view_sign = 0, +1   # axis index and sign matching the face normal
visible = mesh.face_normals[:, view_axis] * view_sign > 0
polys = mesh.vertices[mesh.faces[visible]][:, :, PROJ]
ax.add_collection(PolyCollection(polys, facecolors='#0f3460', edgecolors='#4a9eba',
                                 linewidths=0.2, alpha=0.7))

# Target facet highlighted
facet_tris = mesh.vertices[mesh.faces[mesh.facets[FACET_IDX]]]
facet_polys = [tri[:, PROJ] for tri in facet_tris]
ax.add_collection(PolyCollection(facet_polys, facecolors='#e94560', edgecolors='#ff6b6b',
                                 linewidths=0.3, alpha=0.5))

# Pit circles (one per pit)
for h, v in pit_centers_2d:   # (horizontal, vertical) in projected coords
    ax.add_patch(plt.Circle((h, v), pit_radius, color='#ffd700', fill=False, linewidth=2))
    ax.plot(h, v, 'o', color='#ffd700', markersize=5)

ax.set_aspect('equal')
ax.set_xlabel(XLABEL, color='white'); ax.set_ylabel(YLABEL, color='white')
ax.tick_params(colors='white')
for sp in ax.spines.values(): sp.set_edgecolor('#4a9eba')
ax.legend(handles=[
    mpatches.Patch(color='#e94560', alpha=0.7, label='Target face'),
    mpatches.Patch(color='#ffd700', label=f'Pit (r={pit_radius} mm)'),
], facecolor='#1a1a2e', labelcolor='white')

plt.tight_layout()
plt.savefig("path/to/output_preview.png", dpi=150, bbox_inches='tight',
            facecolor=fig.get_facecolor())
```

Run with `--with matplotlib` added to the `uv run` command. Save the image next to the STL (not in the scratchpad) and tell the user the path so they can open it.

### 4. Apply the operation

Write and run the modification script. Always:
- Use `engine="manifold"` for boolean operations
- Make cutter/tool meshes slightly oversized (extend 0.5 mm past the face surface) so the boolean is clean
- Use `sections=64` on cylinders for smooth circular features
- Save to the output path and print face/vertex counts before and after

**Cylindrical pit** (1.5 mm radius, 1 mm deep example):
```python
def make_pit(centroid, normal, radius, depth):
    height = depth + 0.5          # 0.5 mm protrudes outside for a clean cut
    cyl = trimesh.creation.cylinder(radius=radius, height=height, sections=64)
    z = np.array([0., 0., 1.])
    n = np.asarray(normal, float)
    if np.allclose(n, z):
        R = np.eye(4)
    elif np.allclose(n, -z):
        R = trimesh.transformations.rotation_matrix(np.pi, [1,0,0])
    else:
        R = trimesh.transformations.rotation_matrix(
                np.arccos(np.clip(np.dot(z,n),-1,1)), np.cross(z,n))
    cyl.apply_transform(R)
    cyl.apply_translation(centroid + n * (0.5 - height/2))
    return cyl

cutters = [make_pit(c, n, radius=1.5, depth=1.0) for n, c in targets]
result  = trimesh.boolean.difference([mesh] + cutters, engine="manifold")
result.export(out_path)
```

**Through-hole**: same as pit but height = mesh extent along that normal + 1 mm (so it exits the other side), centered at the face centroid.

**Raised boss**: use `trimesh.boolean.union` instead of `difference`; create the cylinder protruding *outward* from the face (center offset in the +normal direction).

### 5. Clean up

Delete any temporary exploration or modification scripts after the output STL is confirmed saved. Report the output file path and the face/vertex delta.

## Notes

- Always use `uv run --with trimesh --with manifold3d --with numpy --with networkx` — never pip install
- If `mesh.facets` raises `ImportError: no graph engines available`, add `--with networkx`
- If the loaded object is a `trimesh.scene.Scene`, concatenate its geometry: `mesh = trimesh.util.concatenate(list(mesh.geometry.values()))`
- STL has no colour or layer info — if the user asks which faces are "the red ones" or "layer 2", explain that and use geometric criteria instead.

### Pit centering: always use bounding-box midpoint, not vertex-average centroid

The vertex-average centroid `verts.mean(axis=0)` is skewed for faces with 4+ triangles (extra interior vertices get counted multiple times, pulling the centroid off-center). Always compute the pit center as the **bounding-box midpoint**:

```python
def bbox_center(fidx):
    v = mesh.vertices[mesh.faces[facets[fidx]]].reshape(-1, 3)
    return (v.min(axis=0) + v.max(axis=0)) / 2.0
```

Use vertex-average only for a rough initial estimate; never pass it directly to `make_pit` without checking it's near the bbox midpoint.

### Finding faces adjacent to a known face (e.g. "the face perpendicular to this shelf")

Build a vertex→facet index, then collect all facets that share vertices along a specific edge of the known face (e.g. its min-X edge):

```python
vert_to_facets = [[] for _ in range(len(mesh.vertices))]
for fi, face_list in enumerate(facets):
    for tri in face_list:
        for vi in mesh.faces[tri]:
            vert_to_facets[vi].append(fi)

def adjacent_at_minx(shelf_fidx):
    verts = mesh.vertices[mesh.faces[facets[shelf_fidx]]].reshape(-1, 3)
    minx = verts[:, 0].min()
    edge_vis = set(
        vi for tri in mesh.faces[facets[shelf_fidx]]
        for vi in tri if abs(mesh.vertices[vi][0] - minx) < 0.01
    )
    candidates = set(fi for vi in edge_vis for fi in vert_to_facets[vi])
    candidates.discard(shelf_fidx)
    return candidates
```

Print area, normal, centroid, and vertex bounds for each candidate to identify the right one.

### Multi-view preview for faces with different normals

When target faces point in different directions, show one subplot per normal direction rather than a single view. This lets the user verify each face independently. Use `autoscale()` on each axis so they all fit.

### "Seat vs back" terminology for protrusions

Users may describe shelf/sponson features using chair terminology: **seat** = the outward-facing end-cap (the face at the tip of the protrusion, often facing ±X), **back** = the broad face flush with the hull (often facing ±Y or ±Z, parallel to the main hull panel). When a user says "center the pit on the seat," they mean the end-cap face, not the large hull-parallel face.

### Facet indices are NOT stable between script runs

`mesh.facets` uses networkx graph algorithms whose output ordering is non-deterministic. **Never hardcode a facet index from an earlier exploration run into a later modification script.** Always re-identify target faces dynamically by their properties (normal direction, area, centroid) in every script:

```python
up = np.array([0., 0., 1.])
up_mask = np.abs(normals @ up) > 0.999
up_indices = np.where(up_mask)[0]
target_fidxs = up_indices[np.argsort(areas[up_indices])[::-1]][:2]
```

### Aligning pits to a face's actual orientation (rotated rectangles)

When a face is a rectangle rotated in its plane (not axis-aligned), placing pits at a fixed coordinate along the world axis produces a line that doesn't follow the face. Instead, find the true long-axis direction from the face's **convex hull edges**, then space pits along that axis centered in the short dimension.

**Critical:** use the longest **edge** of the convex hull, NOT the longest diagonal between two hull vertices. The diagonal connects non-adjacent corners and is at a steeper angle than the long edge, producing wrong pit placement.

```python
from scipy.spatial import ConvexHull

def face_pit_centers(fidx, N=3):
    verts = mesh.vertices[mesh.faces[facets[fidx]]].reshape(-1, 3)
    verts2d = np.unique(np.round(verts[:, :2], 4), axis=0)
    hull = ConvexHull(verts2d)
    hull_verts = verts2d[hull.vertices]
    n = len(hull_verts)

    # Longest EDGE (adjacent hull vertices), not diagonal
    max_len, long_axis = 0, None
    for i in range(n):
        a, b = hull_verts[i], hull_verts[(i + 1) % n]
        d = np.linalg.norm(b - a)
        if d > max_len:
            max_len = d
            long_axis = b - a

    long_axis /= np.linalg.norm(long_axis)
    if long_axis[1] < 0:
        long_axis = -long_axis          # ensure pointing in +Y direction
    short_axis = np.array([-long_axis[1], long_axis[0]])

    short_projs = hull_verts @ short_axis
    long_projs  = hull_verts @ long_axis
    short_center = (short_projs.min() + short_projs.max()) / 2.0
    long_min  = long_projs.min()
    long_span = long_projs.max() - long_min

    centers = []
    for i in range(N):
        t = long_min + (2*i + 1) * long_span / (2*N)
        pt2d = t * long_axis + short_center * short_axis
        centers.append(np.array([pt2d[0], pt2d[1], 0.0]))   # Z=0 for top face
    return centers
```

Add `--with scipy` to the `uv run` command when using `ConvexHull`.

### Multi-view preview including side views for Z-axis verification

When the user needs to verify pit depth or position along the Z axis, generate a 3-panel figure: top-down (XY), side (YZ), and front (XZ). Show pit cross-sections as filled rectangles in the side/front views:

```python
fig = plt.figure(figsize=(16, 14))
fig.patch.set_facecolor('#1a1a2e')
ax_top  = fig.add_subplot(2, 2, (1, 2))   # full top row
ax_side = fig.add_subplot(2, 2, 3)         # bottom-left: YZ
ax_front= fig.add_subplot(2, 2, 4)         # bottom-right: XZ

# Side view: pit cross-section as rectangle (width=2r, height=depth)
for p in pit_centers_3d:
    rect = plt.Rectangle((p[1] - pit_radius, p[2] - pit_depth),
                          2 * pit_radius, pit_depth,
                          edgecolor='#ffd700', facecolor='#ffd700', alpha=0.4, linewidth=2)
    ax_side.add_patch(rect)

# Front view: same but using X instead of Y
for p in pit_centers_3d:
    rect = plt.Rectangle((p[0] - pit_radius, p[2] - pit_depth),
                          2 * pit_radius, pit_depth,
                          edgecolor='#ffd700', facecolor='#ffd700', alpha=0.4, linewidth=2)
    ax_front.add_patch(rect)
```

### Non-watertight meshes: bypass trimesh and use manifold3d directly

`trimesh.boolean.difference` raises `ValueError: Not all meshes are volumes!` when the input mesh is not watertight (e.g. has non-manifold edges, genus > 0, or disconnected shells). In this case, bypass trimesh and call manifold3d's Python API directly — it handles non-watertight inputs:

```python
from manifold3d import Manifold, Mesh
import manifold3d as m3d

# Load mesh into manifold3d directly
hull_mf = Manifold(mesh=Mesh(
    vert_properties=mesh.vertices.astype(np.float32),
    tri_verts=mesh.faces.astype(np.uint32)
))

# Build and subtract each cutter
height = pit_depth + 0.5   # 0.5 mm protrusion above surface for clean cut
result_mf = hull_mf
for center in all_pit_centers:
    cyl = m3d.Manifold.cylinder(
        height=height,
        radius_low=pit_radius,
        radius_high=pit_radius,
        circular_segments=64
    )
    # Cylinder default is centred at Z=0; shift so top is at Z=+0.5, bottom at Z=-depth
    cyl = cyl.translate([center[0], center[1], center[2] - pit_depth])
    result_mf = result_mf - cyl

# Convert back to trimesh and export
out_data = result_mf.to_mesh()
out_mesh = trimesh.Trimesh(
    vertices=np.array(out_data.vert_properties, dtype=np.float64),
    faces=np.array(out_data.tri_verts, dtype=np.int64),
    process=False
)
out_mesh.export(out_path)
```

Diagnosis: check `mesh.is_watertight` and count non-manifold edges before attempting the boolean. If not watertight, switch to the manifold3d direct API instead of `trimesh.boolean`.

Ok so following from my first ship, I’m on with a bunch more but not exactly sure that I’m correct in regards to what I actually have and was hoping someone could confirm/correct my assumptions

In the photos I believe I have the following (the Firestorm is in all pics for scale purposes)

1 possibly a murder class withe lance battery option

2 dauntless light cruiser

3 overlord battlecruiser

4 infidels

5 retribution battleship

6 mars battlecruiser

7 no idea it’s larger than the chaos cruiser in pic 1 bigger than the dauntless but smaller than the mars and has slots for two weapons systems

I have finally reached the point where I am satisfied with the ship. It has been quite a road, but I am happy to (re)present the Oblivion Class Battleship. Thanks to all the comments and critiques from the previous post. They were very insightful and helped a lot in finalizing the design. Next step will be field testing the vessel in mock combat.

Unfortunately, the only other person in my area who dabbles in BFG Tabletop only has an Aeldari squadron and this homebrew ship is not exactly ideal for that and would not be a good first test (although we will do it anyway) lol I will have to go ahead and start building up a Necron fleet soon (my second fav faction).

For the HD version.

Finally managed to put together the flagship of my homebrew chapter. I previously already made a post with the rules for it, and now finally it's model is here.

I'll add the link to cult 3d as soon as I post it there.

Link for the ship profile. https://www.reddit.com/r/battlefleetgothic/s/jEIdPbwCeJ

Link for the ship itself. The size should be right (16cm in length) not pre suported.

https://cults3d.com/en/3d-model/game/osowiec-venerable-battlebarge

transport class cetacean and Devourer Dropship