diff --git a/lmfdb/galois_groups/code.yaml b/lmfdb/galois_groups/code.yaml
index dfd89d4026..8c623980b1 100644
--- a/lmfdb/galois_groups/code.yaml
+++ b/lmfdb/galois_groups/code.yaml
@@ -2,11 +2,13 @@ prompt:
   magma: 'magma'
   sage:  'sage'
   oscar: 'oscar'
+  gap:   'gap'
 
 logo:
   magma: <img src = "https://i.stack.imgur.com/0468s.png" width="50px">
   sage: <img src ="https://www.sagemath.org/pix/sage_logo_new.png" width = "50px">
   oscar: <img src = "https://oscar-system.github.io/Oscar.jl/stable/assets/logo.png" width="50px">
+  gap: <img src = "https://gap.math.u-bordeaux.fr/logo/Logo%20Couleurs/Logo_GAP-GP_Couleurs_L150px.png" width="50px">
 
 comment:
   sage: |
@@ -15,6 +17,8 @@ comment:
     //
   oscar: |
     #
+  gap: |
+    #
 
 not-implemented:
   sage: |
@@ -23,6 +27,9 @@ not-implemented:
     // (not yet implemented)
   oscar: |
     # (not yet implemented)
+  gap: |
+    # (not yet implemented)
+
 
 frontmatter:
   all: |
@@ -33,89 +40,105 @@ gg:
   magma: G := TransitiveGroup({n}, {t});
   sage: G = TransitiveGroup({n}, {t})  
   oscar: G = transitive_group({n}, {t})
+  gap: G := TransitiveGroup({n}, {t});
 
 n:
   comment: Degree
   magma: t, n := TransitiveGroupIdentification(G); n;
   sage: G.degree()
   oscar: degree(G)
+  gap: NrMovedPoints(G);
 
 t:
   comment: Transitive number
   magma: t, n := TransitiveGroupIdentification(G); t;
   sage: G.transitive_number()
   oscar: transitive_group_identification(G)[2]
+  gap: TransitiveIdentification(G);
 
 primitive:
   comment: Determine if group is primitive
   magma: IsPrimitive(G);
   sage: G.is_primitive()
   oscar: is_primitive(G)
+  gap: IsPrimitive(G);
 
 even:
   comment: Parity
   magma: IsEven(G);
   sage: all(g.SignPerm() == 1 for g in libgap(G).GeneratorsOfGroup())
   oscar: is_even(G)
+  gap: ForAll(GeneratorsOfGroup(G), g -> SignPerm(g) = 1);
 
 nilpotent:
   comment: Nilpotency class
   magma: NilpotencyClass(G);
   sage: libgap(G).NilpotencyClassOfGroup() if G.is_nilpotent() else -1
   oscar: if is_nilpotent(G) nilpotency_class(G) end
+  gap: if IsNilpotentGroup(G) then NilpotencyClassOfGroup(G); fi;
 
 auts:
   comment: Order of the centralizer of G in S_n
   magma: Order(Centralizer(SymmetricGroup(n), G));
   sage: SymmetricGroup({n}).centralizer(G).order()
   oscar: order(centralizer(symmetric_group({n}), G)[1])
+  gap: Order(Centralizer(SymmetricGroup({n}), G));
 
 gens:
   comment: Generators
   magma: Generators(G);
   sage: G.gens()
   oscar: gens(G)
+  gap: GeneratorsOfGroup(G);
 
 ccs:
   comment: Conjugacy classes
   magma: ConjugacyClasses(G);
   sage: G.conjugacy_classes()
   oscar: conjugacy_classes(G)
+  gap: ConjugacyClasses(G);
 
 order:
   comment: Order
   magma: Order(G);
   sage: G.order()
   oscar: order(G)
+  gap: Order(G);
 
 cyclic:
   comment: Determine if group is cyclic
   magma: IsCyclic(G);
   sage: G.is_cyclic()
   oscar: is_cyclic(G)
+  gap: IsCyclic(G);
 
 abelian:
   comment: Determine if group is abelian
   magma: IsAbelian(G);
   sage: G.is_abelian()
   oscar: is_abelian(G)
+  gap: IsAbelian(G);
 
 solvable:
   comment: Determine if group is solvable
   magma: IsSolvable(G);
   sage: G.is_solvable()
   oscar: is_solvable(G)
+  gap: IsSolvable(G);
 
 id:
   comment: Abstract group ID
   magma: IdentifyGroup(G);
   sage: G.id()
+  oscar: small_group_identification(G)
+  gap: IdGroup(G);
 
 char_table:
   comment: Character table
   magma: CharacterTable(G);
   sage: G.character_table()
   oscar: character_table(G)
+  gap: CharacterTable(G);
 
 
 # specify which code snippets to test
diff --git a/lmfdb/galois_groups/main.py b/lmfdb/galois_groups/main.py
index b59325282a..98f73c654a 100644
--- a/lmfdb/galois_groups/main.py
+++ b/lmfdb/galois_groups/main.py
@@ -353,7 +353,7 @@ def render_group_webpage(args):
         data['dispv'] = sparse_cyclotomic_to_mathml
         data['malle_a'] = wgg.malle_a
         downloads = []
-        for lang in [("Magma", "magma"), ("Oscar", "oscar"), ("SageMath", "sage")]:
+        for lang in [("Gap", "gap"), ("Magma", "magma"), ("Oscar", "oscar"), ("SageMath", "sage")]:
             downloads.append(('{} commands'.format(lang[0]), url_for(".gg_code_download", label=label, download_type=lang[1])))
         downloads.append(('Underlying data', url_for(".gg_data", label=label)))
         # split the label so that breadcrumbs point to a search for this object's degree
diff --git a/lmfdb/groups/abstract/code.yaml b/lmfdb/groups/abstract/code.yaml
index eeffa1afba..99fc92233a 100644
--- a/lmfdb/groups/abstract/code.yaml
+++ b/lmfdb/groups/abstract/code.yaml
@@ -3,13 +3,14 @@ prompt:
   gap: 'gap'
   sage: 'sage'
   sage_gap: 'sage'   # For implementing groups in SageMath, but using the GAP interface
+  oscar: 'oscar'
 
 logo:
   magma: <img src = "https://i.stack.imgur.com/0468s.png" width="50px">
   gap: <img src = "https://gap.math.u-bordeaux.fr/logo/Logo%20Couleurs/Logo_GAP-GP_Couleurs_L150px.png" width="50px">
   sage: <img src ="https://www.sagemath.org/pix/sage_logo_new.png" width = "50px">
   sage_gap: <img src ="https://www.sagemath.org/pix/sage_logo_new.png" width = "50px">
-
+  oscar: <img src = "https://oscar-system.github.io/Oscar.jl/stable/assets/logo.png" width="50px">
 
 comment:
   magma: |
@@ -20,7 +21,8 @@ comment:
     #
   sage_gap: |
     #
-
+  oscar: |
+    #
 
 not-implemented:
   magma: |
@@ -31,7 +33,14 @@ not-implemented:
     # (not yet implemented)
   sage_gap: |
     # (not yet implemented)
+  oscar: |
+    # (not yet implemented)
 
+frontmatter:
+  all: |
+    {lang} code for working with abstract group {label}.
+  rest: |
+    Some of these functions may take a long time to execute (this depends on the group).
 
 presentation:
   comment: Define the group with the given generators and relations
@@ -49,6 +58,8 @@ permutation:
   magma: G := PermutationGroup< {deg} | {perms} >;
   gap: G := Group( {perms} );
   sage: G = PermutationGroup([{perms_sage}])
+  sage_gap: G = gap.new('Group( {perms} )')
+  oscar: G = @permutation_group({deg}, {perms})
 
 GLZ:
   comment: Define the group as a matrix group with coefficients in Z
@@ -57,6 +68,8 @@ GLZ:
   sage: |
     MS = MatrixSpace(Integers(), {nZ}, {nZ})
     G = MatrixGroup({LZsage})
+  sage_gap: G = gap.new('Group({LZsplit})')
+  oscar: G = matrix_group({LZoscar})
 
 GLFp:
   comment: Define the group as a matrix group with coefficients in GLFp
@@ -65,6 +78,8 @@ GLFp:
   sage: |
     MS = MatrixSpace(GF({Fp}), {nFp}, {nFp})
     G = MatrixGroup({LFpsage})
+  sage_gap: G = gap.new('Group({LFpsplit})')
+  oscar: G = matrix_group({LFposcar})
 
 GLZN:
   comment: Define the group as a matrix group with coefficients in GLZN
@@ -73,6 +88,8 @@ GLZN:
   sage: |
     MS = MatrixSpace(Integers({N}), {nZN}, {nZN})
     G = MatrixGroup({LZNsage})
+  sage_gap: G = gap.new('Group({LZNsplit})')
+  oscar: G = matrix_group({LZNoscar})
 
 GLZq:
   comment: Define the group as a matrix group with coefficients in GLZq
@@ -81,6 +98,8 @@ GLZq:
   sage: |
     MS = MatrixSpace(Integers({Zq}), {nZq}, {nZq})
     G = MatrixGroup({LZqsage})
+  sage_gap: G = gap.new('Group({LZqsplit})')
+  oscar: G = matrix_group({LZqoscar})
 
 GLFq:
   comment: Define the group as a matrix group with coefficients in GLFq
@@ -89,56 +108,69 @@ GLFq:
   sage: |
     F = GF({Fq}); al = F.0; MS = MatrixSpace(F, {nFq}, {nFq})
     G = MatrixGroup({LFqsage})
+  sage_gap: G = gap.new('Group({LFqsplit})')
+  oscar: F = GF({Fq}); al = gen(F); G = matrix_group({LFqoscar})
 
 
 transitive:
   comment: Define the group from the transitive group database
-  magma: G := TransitiveGroup(d,n);
-  gap: G := TransitiveGroup(d,n);
-  sage: G = TransitiveGroup(d,n)
+  magma: G := TransitiveGroup({deg}, {t});
+  gap: G := TransitiveGroup({deg}, {t});
+  sage: G = TransitiveGroup({deg}, {t})
+  sage_gap: G = libgap.TransitiveGroup({deg}, {t})
+  oscar: G = transitive_group({deg}, {t})
 
 order:
   comment: Order of the group
   magma: Order(G);
   gap: Order(G);
-  sage:  G.order()
-  sage_gap:  G.Order()
+  sage: G.order()
+  sage_gap: G.Order()
+  oscar: order(G)
 
 exponent:
   comment: Exponent of the group
   magma: Exponent(G);
   gap: Exponent(G);
-  sage:  G.exponent()
-  sage_gap:  G.Exponent()
+  sage: G.exponent()
+  sage_gap: G.Exponent()
+  oscar: exponent(G)
 
 automorphism_group:
   comment: Automorphism group
   gap: AutomorphismGroup(G);
   magma: AutomorphismGroup(G);
+  sage: libgap(G).AutomorphismGroup()
   sage_gap: G.AutomorphismGroup()
+  oscar: automorphism_group(G)
 
 outer_automorphism_group:
   comment: The outer automorphism group of G
-  gap:  FactorGroup(AutomorphismGroup(G), InnerAutomorphismGroup(G));
+  gap: FactorGroup(AutomorphismGroup(G), InnerAutomorphismGroup(G));
 
 composition_factors:
   comment: Composition factors of the group
   magma: CompositionFactors(G);
-  gap:  CompositionSeries(G);
-  sage:  G.composition_series()
+  gap: CompositionSeries(G);
+  sage: G.composition_series()
   sage_gap: G.CompositionSeries()
+  oscar: composition_series(G)
 
 nilpotency_class:
-  comment:  Nilpotency class of the group
+  comment: Nilpotency class of the group
   magma: NilpotencyClass(G);
-  gap: NilpotencyClassOfGroup(G);
-  sage_gap: G.NilpotencyClassOfGroup()
+  gap: if IsNilpotentGroup(G) then NilpotencyClassOfGroup(G); fi;
+  sage: libgap(G).NilpotencyClassOfGroup() if G.is_nilpotent() else -1
+  sage_gap: G.NilpotencyClassOfGroup() if G.IsNilpotentGroup() else -1
+  oscar: if is_nilpotent(G) nilpotency_class(G) end
 
 derived_length:
   comment:  Derived length of the group
   magma:  DerivedLength(G);
   gap: DerivedLength(G);
+  sage: libgap(G).DerivedLength()
   sage_gap:  G.DerivedLength()
+  oscar: derived_length(G)
 
 is_abelian:
   comment:  Determine if the group G is abelian
@@ -146,6 +178,7 @@ is_abelian:
   gap:  IsAbelian(G);
   sage: G.is_abelian()
   sage_gap:  G.IsAbelian()
+  oscar: is_abelian(G)
 
 is_cyclic:
   comment:  Determine if the group G is cyclic
@@ -153,6 +186,7 @@ is_cyclic:
   gap:  IsCyclic(G);
   sage: G.is_cyclic()
   sage_gap:  G.IsCyclic()
+  oscar: is_cyclic(G)
 
 is_elementary_abelian:
   comment:  Determine if the group G is elementary abelian
@@ -160,31 +194,35 @@ is_elementary_abelian:
   gap: IsElementaryAbelian(G);
   sage: G.is_elementary_abelian()
   sage_gap:  G.IsElementaryAbelian()
+  oscar: is_elementary_abelian(G)
 
 is_monomial:
   comment:  Determine if the group G is a monomial group
   gap: IsMonomialGroup(G);
-  sage_gap:  G.IsMonomialGroup()
+  sage_gap: G.IsMonomialGroup()
 
 is_nilpotent:
   comment: Determine if the group G is nilpotent
   magma: IsNilpotent(G);
   gap: IsNilpotentGroup(G);
   sage: G.is_nilpotent()
-  sage_gap:  G.IsNilpotentGroup()
+  sage_gap: G.IsNilpotentGroup()
+  oscar: is_nilpotent(G)
 
 is_perfect:
   comment:  Determine if the group G is perfect
   magma:  IsPerfect(G);
   gap: IsPerfectGroup(G);
   sage: G.is_perfect()
-  sage_gap:  G.IsPerfect()
+  sage_gap: G.IsPerfect()
+  oscar: is_perfect(G)
 
 is_pgroup:
   comment:  Determine if the group G is a p-group
   gap:  IsPGroup(G);
   sage: G.is_pgroup()
   sage_gap: G.IsPGroup()
+  oscar: is_pgroup(G)
 
 is_polycyclic:
   comment:  Determine if the group G is polycyclic
@@ -196,7 +234,9 @@ is_simple:
   comment:  Determine if the group G is simple
   magma: IsSimple(G);
   gap:  IsSimpleGroup(G);
-  sage_gap:  G.IsSimpleGroup()
+  sage: G.is_simple()
+  sage_gap: G.IsSimpleGroup()
+  oscar: is_simple(G)
 
 is_solvable:
   comment: Determine if the group G is solvable
@@ -204,12 +244,14 @@ is_solvable:
   gap: IsSolvableGroup(G);
   sage:  G.is_solvable()
   sage_gap:  G.IsSolvableGroup()
+  oscar: is_solvable(G)
 
 is_supersolvable:
   comment:  Determine if the group G is supersolvable
   gap: IsSupersolvableGroup(G);
   sage: G.is_supersolvable()
   sage_gap:  G.IsSupersolvableGroup()
+  oscar: is_supersolvable(G)
 
 
 group_statistics:
@@ -240,17 +282,38 @@ group_statistics:
     print("Elements:", [element_orders.count(n) for n in orders], G.order())
     cc_orders = [cc[0].order() for cc in G.conjugacy_classes()]
     print("Conjugacy classes:", [cc_orders.count(n) for n in orders], len(cc_orders))
+  sage_gap: |
+    # Sage code (using the GAP interface) to output the first two rows of the group statistics table
+    element_orders = [g.Order() for g in G.Elements()]
+    orders = sorted(list(set(element_orders)))
+    print("Orders:", orders)
+    print("Elements:", [element_orders.count(n) for n in orders], G.Order())
+    cc_orders = [cc.Representative().Order() for cc in G.ConjugacyClasses()]
+    print("Conjugacy classes:", [cc_orders.count(n) for n in orders], len(cc_orders))
+  oscar: |
+    # Oscar code to output the first two rows of the group statistics table
+    element_orders = [order(g) for g in elements(G)]
+    orders = sort(unique(element_orders))
+    println("Orders: ", orders)
+    element_counts = [count(==(n), element_orders) for n in orders]
+    println("Elements: ", element_counts, " ", order(G))
+    ccs = conjugacy_classes(G)
+    cc_orders = [order(representative(cc)) for cc in ccs]
+    cc_counts = [count(==(n), cc_orders) for n in orders]
+    println("Conjugacy classes: ", cc_counts, " ", length(ccs))
 
 conjugacy_classes:
   comment: List of conjugacy classes of the group
   magma: |
     ConjugacyClasses(G);  // Output not guaranteed to exactly match the LMFDB table
   gap: |
-    ConjugacyClasses(G);   # Output not guaranteed to exactly match the LMFDB table
+    ConjugacyClasses(G);  # Output not guaranteed to exactly match the LMFDB table
   sage: |
     G.conjugacy_classes()  # Output not guaranteed to exactly match the LMFDB table
   sage_gap: |
     G.ConjugacyClasses()  # Output not guaranteed to exactly match the LMFDB table
+  oscar: |
+    conjugacy_classes(G)  # Output not guaranteed to exactly match the LMFDB table
 
 character_statistics:
   comment:  Compute statistics about the characters of G
@@ -264,9 +327,12 @@ character_statistics:
     # Outputs [[d_1,c_1], [d_2,c_2], ...] where c_i is the number of irr. complex chars. of G with degree d_i
     character_degrees = [c[0] for c in G.character_table()]
     [[n, character_degrees.count(n)] for n in set(character_degrees)]
-  sage_gap:
+  sage_gap: |
     # Outputs [[d_1,c_1], [d_2,c_2], ...] where c_i is the number of irr. complex chars. of G with degree d_i
     G.CharacterDegrees()
+  oscar: |
+    # Outputs an MSet containing the absolutely irreducible degrees of G and their multiplicities.
+    character_degrees(G)
 
 
 primary_decomposition:
@@ -274,12 +340,15 @@ primary_decomposition:
   magma:  PrimaryInvariants(G);
   gap:  AbelianInvariants(G);
   sage_gap: G.AbelianInvariants()
+  oscar: abelian_invariants(G)
 
 abelianization:
-  comment:  The abelianization of the group
-  magma:  quo< G | CommutatorSubgroup(G) >;
-  gap:  FactorGroup(G, DerivedSubgroup(G));
-  sage:  G.quotient(G.commutator())
+  comment: The abelianization of the group
+  magma: quo< G | CommutatorSubgroup(G) >;
+  gap: FactorGroup(G, DerivedSubgroup(G));
+  sage: G.quotient(G.commutator())
+  sage_gap: G.FactorGroup(G.DerivedSubgroup())
+  oscar: quo(G, derived_subgroup(G)[1])
 
 schur_multiplier:
   comment:  The Schur multiplier of the group
@@ -288,37 +357,41 @@ schur_multiplier:
   sage_gap:  G.AbelianInvariantsMultiplier()
 
 commutator_length:
-  comment:  The commutator length of the group
+  comment: The commutator length of the group
   gap: CommutatorLength(G);
   sage_gap: G.CommutatorLength()
 
 subgroups:
-  comment:  List of subgroups of the group
-  magma:  Subgroups(G);
-  gap:  AllSubgroups(G);
-  sage:   G.subgroups()
+  comment: List of subgroups of the group
+  magma: Subgroups(G);
+  gap: AllSubgroups(G);
+  sage: G.subgroups()
   sage_gap: G.AllSubgroups()
+  oscar: subgroups(G)
 
 center:
   comment: Center of the group
   magma: Center(G);
-  gap:  Center(G);
-  sage:  G.center()
-  sage_gap:  G.Center()
+  gap: Center(G);
+  sage: G.center()
+  sage_gap: G.Center()
+  oscar: center(G)
 
 commutator_subgroup:
   comment: Commutator subgroup of the group G
-  magma:  CommutatorSubgroup(G);
-  gap:  DerivedSubgroup(G);
-  sage:  G.commutator()
-  sage_gap:  G.DerivedSubgroup()
+  magma: CommutatorSubgroup(G);
+  gap: DerivedSubgroup(G);
+  sage: G.commutator()
+  sage_gap: G.DerivedSubgroup()
+  oscar: derived_subgroup(G)
 
 frattini_subgroup:
   comment: Frattini subgroup of the group G
-  magma:  FrattiniSubgroup(G);
+  magma: FrattiniSubgroup(G);
   gap: FrattiniSubgroup(G);
-  sage:  G.frattini_subgroup()
+  sage: G.frattini_subgroup()
   sage_gap: G.FrattiniSubgroup()
+  oscar: frattini_subgroup(G)
 
 fitting_subgroup:
   comment:  Fitting subgroup of the group G
@@ -326,12 +399,14 @@ fitting_subgroup:
   gap:  FittingSubgroup(G);
   sage:  G.fitting_subgroup()
   sage_gap: G.FittingSubgroup()
+  oscar: fitting_subgroup(G)
 
 radical:
   comment: Radical of the group G
   magma:  Radical(G);
   gap: SolvableRadical(G);
   sage_gap: G.SolvableRadical()
+  oscar: solvable_radical(G)
 
 socle:
   comment:  Socle of the group G
@@ -339,19 +414,23 @@ socle:
   gap:  Socle(G);
   sage:  G.socle()
   sage_gap: G.Socle()
+  oscar: socle(G)
 
 derived_series:
-  comment:  Derived series of the group GF
+  comment:  Derived series of the group G
   magma:  DerivedSeries(G);
   gap: DerivedSeriesOfGroup(G);
   sage: G.derived_series()
   sage_gap:  G.DerivedSeriesOfGroup()
+  oscar: derived_series(G)
 
 chief_series:
   comment:  Chief series of the group G
   magma:  ChiefSeries(G);
   gap: ChiefSeries(G);
+  sage: libgap(G).ChiefSeries()
   sage_gap:  G.ChiefSeries()
+  oscar: chief_series(G)
 
 lower_central_series:
   comment:  The lower central series of the group G
@@ -359,13 +438,15 @@ lower_central_series:
   gap: LowerCentralSeriesOfGroup(G);
   sage: G.lower_central_series()
   sage_gap:  G.LowerCentralSeriesOfGroup()
+  oscar: lower_central_series(G)
 
 upper_central_series:
   comment: The upper central series of the group G
-  magma:  UpperCentralSeries(G);
+  magma: UpperCentralSeries(G);
   gap: UpperCentralSeriesOfGroup(G);
   sage: G.upper_central_series()
-  sage_gap:  G.UpperCentralSeriesOfGroup()
+  sage_gap: G.UpperCentralSeriesOfGroup()
+  oscar: upper_central_series(G)
 
 character_table:
   comment: Character table
@@ -377,3 +458,86 @@ character_table:
     G.character_table()  # Output not guaranteed to exactly match the LMFDB table
   sage_gap: |
     G.CharacterTable()  # Output not guaranteed to exactly match the LMFDB table
+  oscar: |
+    character_table(G)  # Output not guaranteed to exactly match the LMFDB table
+
+
+# Code snippets for special group families (used in the construction of the top code snippet)
+cyclic_group:
+  comment: Define group as a cyclic group
+  magma: G := CyclicGroup({ordgp});
+  gap: G := CyclicGroup({ordgp});
+  sage: G = CyclicPermutationGroup({ordgp})
+  sage_gap: G = libgap.eval('CyclicGroup({ordgp})')
+  oscar:  G = cyclic_group({ordgp})
+
+symmetric_group:
+  comment: Define group as a symmetric group
+  magma:  G := SymmetricGroup({symn});
+  gap:  G := SymmetricGroup({symn});
+  sage: G = SymmetricGroup({symn})
+  sage_gap: G = libgap.eval('SymmetricGroup({symn})')
+  oscar: G = symmetric_group({symn})
+
+dihedral_group:
+  comment: Define group as a dihedral group
+  magma: G := DihedralGroup({ordgp_half});             # Magma D(n) has order 2n
+  gap:  G := DihedralGroup({ordgp});                   # GAP D(n) has order n
+  sage:  G = DihedralGroup({ordgp_half})               # Sage D(n) has order 2n
+  sage_gap: G = libgap.eval('DihedralGroup({ordgp})')  # Sage GAP D(n) has order n
+  oscar:  G = dihedral_group({ordgp})                  # Oscar D(n) has order n
+
+alternating_group:
+  comment: Define group as an alternating group
+  magma:  G := AlternatingGroup({altn});
+  gap:  G := AlternatingGroup({altn});
+  sage: G = AlternatingGroup({altn})
+  sage_gap: G = libgap.eval('AlternatingGroup({altn})')
+  oscar: G = alternating_group({altn})
+
+dicyclic_group:
+  comment: Define group as a dicyclic group
+  magma:  G := DicyclicGroup({ordgp_quarter});         # Magma Dic(n) has order 4n
+  gap:  G := DicyclicGroup({ordgp});                   # GAP Dic(n) has order n
+  sage:  G = DiCyclicGroup({ordgp_quarter})            # Sage Dic(n) has order 4n
+  sage_gap: libgap.eval('DicyclicGroup({ordgp})')      # Sage GAP Dic(n) has order n
+  oscar:  G = dicyclic_group({ordgp})                  # Oscar Dic(n) has order n
+
+chevalley_group:
+  comment: Define group as a Chevalley group
+  magma: G := ChevalleyGroup("{chev_fam}", {chev_params});
+
+small_group:
+  comment: Define group as element of the GAP SmallGroups database
+  magma: G := SmallGroup({ordgp}, {gap_id});
+  gap: G := SmallGroup({ordgp}, {gap_id});
+  sage_gap: G = libgap.SmallGroup({ordgp}, {gap_id})
+  oscar: G = small_group({ordgp}, {gap_id})
+
+abelian_group:
+  comment: Define group as an abelian group
+  magma: G := AbelianGroup({abelian_invariants});
+  gap:  G := AbelianGroup({abelian_invariants});
+  sage: G = AbelianGroup({abelian_invariants})
+  sage_gap: G = libgap.eval('AbelianGroup({abelian_invariants})')
+  oscar: G = abelian_group({abelian_invariants})
+
+
+# Code snippet tests for abstract group pages
+snippet_test:
+  # Trivial group
+  testC1:
+    label: C1
+    url: Groups/Abstract/1.1/codedownload/{lang}
+  # Symmetric group S_3
+  testS3:
+    label: S3
+    url: Groups/Abstract/6.1/codedownload/{lang}
+  # Dihedral group D_4 (of order 8)
+  testD4:
+    label: D4
+    url: Groups/Abstract/8.3/codedownload/{lang}
+  # Alternating group A_5
+  testA5:
+    label: A5
+    url: Groups/Abstract/60.5/codedownload/{lang}
diff --git a/lmfdb/groups/abstract/main.py b/lmfdb/groups/abstract/main.py
index 449222216d..aaac66bb92 100644
--- a/lmfdb/groups/abstract/main.py
+++ b/lmfdb/groups/abstract/main.py
@@ -49,6 +49,7 @@
     sparse_cyclotomic_to_mathml,
     integer_to_mathml,
     redirect_no_cache,
+    CodeSnippet,
 )
 from lmfdb.utils.search_parsing import (parse_multiset, search_parser, collapse_ors)
 from lmfdb.utils.interesting import interesting_knowls
@@ -1889,6 +1890,11 @@ def render_abstract_group(label, data=None):
     info['pos_int_and_factor'] = pos_int_and_factor
     info['conv'] = integer_to_mathml
     info['dispv'] = sparse_cyclotomic_to_mathml
+
+    code = gp.code_snippets()
+    if code and len(code['prompt']) == 0:  # no codes
+        code = None
+
     if gp.live():
         title = f"Abstract group {label}"
         friends = []
@@ -1906,10 +1912,12 @@ def render_abstract_group(label, data=None):
 
         # disable until we can fix downloads
         downloads = [("Group to Gap", url_for(".download_group", label=label, download_type="gap")),
-                                         ("Group to Magma", url_for(".download_group", label=label, download_type="magma")),
-                #            ("Group to Oscar", url_for(".download_group", label=label, download_type="oscar")),
-                                         ("Underlying data", url_for(".gp_data", label=label)),
-        ]
+                     ("Group to Magma", url_for(".download_group", label=label, download_type="magma"))]
+                     #("Group to Oscar", url_for(".download_group", label=label, download_type="oscar")),
+        for lang in [("Gap","gap"), ("Magma","magma"), ("SageMath","sage"), ("SageMath (using Gap)","sage_gap"), ("Oscar","oscar")]:
+            if lang[1] in code['prompt']:
+                downloads.append(('{} commands'.format(lang[0]), url_for(".download_group_code", label=label, download_type=lang[1])))
+        downloads.append(("Underlying data", url_for(".gp_data", label=label)))
 
         # "internal" friends
         sbgp_of_url = (
@@ -1977,9 +1985,7 @@ def render_abstract_group(label, data=None):
 
     bread = get_bread([(gp.label_compress(), "")])
     learnmore_gp_picture = ('Picture description', url_for(".picture_page"))
-    code = gp.code_snippets()
-    if code and len(code['prompt']) == 0:  # no codes
-        code = None
+    
 
     return render_template(
         "abstract-show-group.html",
@@ -2570,6 +2576,41 @@ def download_group(**args):
     #strIO.seek(0)
     #return send_file(strIO, attachment_filename=filename, as_attachment=True, add_etags=False)
 
+# Sorted list of abstract group code snippets to download
+sorted_code_names = ["code_description", "order", "exponent", "automorphism_group", "outer_automorphism_group", "composition_factors",
+                     "nilpotency_class", "derived_length", "is_abelian", "is_cyclic", "is_elementary_abelian", "is_monomial", 
+                     "is_nilpotent", "is_perfect", "is_pgroup", "is_polycyclic", "is_simple", "is_solvable", "is_supersolvable", 
+                     "group_statistics", "conjugacy_classes", "character_statistics", "lie_reps_all", "presentation", "permutation",
+                     "GLZ", "GLFp", "GLZN", "GLZq", "GLFq", "transitive_all", "primary_decomposition", "abelianization",
+                     "schur_multiplier", "commutator_length", "subgroups", "center", "commutator_subgroup", "frattini_subgroup",
+                     "fitting_subgroup", "radical", "socle", "derived_series", "chief_series", "lower_central_series", 
+                     "upper_central_series", "character_table"]
+
+@abstract_page.route("/<label>/codedownload/<download_type>")
+def download_group_code(label, download_type):
+    try:
+        grp = WebAbstractGroup(label)
+        code_snippets = grp.code_snippets()
+
+        # Maybe we should remove all instances of "G = " and "G := ", except for the top code snippet
+        # This ensures all the code snippets work (in sequential order) in the code download files
+        for rep in ["lie_reps_all", "permutation", "GLZ", "GLFp", "GLZN", "GLZq", "GLFq", "transitive_all"]:
+            if rep in code_snippets:
+                for lang in code_snippets[rep]:
+                    code_snippets[rep][lang] = code_snippets[rep][lang].replace("G = ", '').replace("G := ", '')
+
+        # We need to still assign the PC representation to some variable (e.g. "GPC"), for this command to work
+        if "presentation" in code_snippets:
+            for lang in code_snippets["presentation"]:
+                code_snippets["presentation"][lang] = code_snippets["presentation"][lang].replace("G :=", "GPC :=").replace("G =", "GPC =").replace("G.", "GPC.").replace("G,", "GPC,")
+
+        code = CodeSnippet(code_snippets)
+        response = make_response(code.export_code(label, download_type, sorted_code_names))
+    except Exception as err:
+        return abort(404, str(err))
+    response.headers['Content-type'] = 'text/plain'
+    return response
+
 @abstract_page.route("/search_diagram/")
 def browseDiagram():
     info = to_dict(request.args, search_array=GroupsSearchArray())
@@ -3737,7 +3778,7 @@ def order_stats_list_to_string(o_list):
     return s
 
 
-sorted_code_names = ['presentation', 'permutation', 'matrix', 'transitive']
+#sorted_code_names = ['presentation', 'permutation', 'matrix', 'transitive']
 
 Fullname = {'magma': 'Magma', 'gap': 'Gap'}
 Comment = {'magma': '//', 'gap': '#'}
diff --git a/lmfdb/groups/abstract/web_groups.py b/lmfdb/groups/abstract/web_groups.py
index f4a1bc450e..966641c8c4 100644
--- a/lmfdb/groups/abstract/web_groups.py
+++ b/lmfdb/groups/abstract/web_groups.py
@@ -2350,7 +2350,7 @@ def representation_line(self, rep_type, skip_head=False):
         if rep_type == "Lie":
             desc = "Groups of " + display_knowl("group.lie_type", "Lie type")
             reps = ", ".join(fr"$\{rep['family']}({rep['d']},{rep['q']})$" for rep in rdata)
-            code_cmd = " ".join([self.create_lie_type_snippet((rep['family'], rep['d'], rep['q'])) for rep in rdata])
+            code_cmd = " ".join([self.create_short_snippet((rep['family'], rep['d'], rep['q'])) for rep in rdata])
             return f'<tr><td>{desc}:</td><td colspan="5">{reps}</td></tr><tr><td colspan="6">{code_cmd}</td></tr>'
         elif rep_type == "PC":
             pres = self.presentation()
@@ -2359,7 +2359,7 @@ def representation_line(self, rep_type, skip_head=False):
                 pres = raw_typeset(pres_raw,compress_pres(pres))
                 if self.live():  # skip code snippet on live group for now
                     return f'<tr><td>{display_knowl("group.presentation", "Presentation")}:<td><td colspan="5">{pres}</td></tr>'
-                code_cmd = self.create_snippet('presentation')
+                code_cmd = self.create_long_snippet('presentation')
             else:
                 pres = " $" + pres + "$"
             if self.abelian and not self.cyclic:
@@ -2377,7 +2377,7 @@ def representation_line(self, rep_type, skip_head=False):
             if self.live():  # skip code snippet on live group for now
                 code_cmd = ""
             else:
-                code_cmd = self.create_snippet('permutation')
+                code_cmd = self.create_long_snippet('permutation')
             if d >= 10:
                 gens = f"Degree ${d}$" + gens
             return f'<tr><td>{display_knowl("group.permutation_gens", "Permutation group")}:</td><td colspan="5">{gens}</td></tr>{code_cmd}'
@@ -2391,7 +2391,7 @@ def representation_line(self, rep_type, skip_head=False):
                 poly = latex(Fq.polynomial())
                 ambient += fr" = \GL_{{{d}}}(\F_{{{N}}}[\alpha]/({poly}))"
             gens = fr"$\left\langle {gens} \right\rangle \subseteq {ambient}$"
-            code_cmd = self.create_snippet(rep_type)
+            code_cmd = self.create_long_snippet(rep_type)
             if skip_head:
                 return f'<tr><td></td><td colspan="5">{gens}</td></tr>{code_cmd}'
             else:
@@ -2500,7 +2500,7 @@ def show_reps(rtype):
             elif rtype == "transitive":
                 if not abstract_group_label_regex.fullmatch(self.label):
                     return ""
-                return rep_line(
+                rep_content = rep_line(
                     "group.permutation_representation",
                     "Transitive group",
                     content_from_opts(self.transitive_friends,
@@ -2508,6 +2508,11 @@ def show_reps(rtype):
                                       False, # hide if not present
                                       display_transitive,
                                       transitive_expressions_knowl))
+                
+                # Display code snippets for transitive group representations
+                code_cmd = " ".join([self.create_short_snippet(trans) for trans in self.transitive_friends])
+                return rep_content + f'<tr><td colspan="6">{code_cmd}</td></tr>'
+
             elif rtype == "semidirect":
                 return rep_line(
                     "group.semidirect_product",
@@ -2850,21 +2855,31 @@ def image(self):
             circles = ""
         return f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="-{R} -{R} {2*R} {2*R}" width="200" height="150">\n{circles}</svg>'
 
-    def create_snippet(self,item):
+    # Used for displaying code snippets across multiple columns in a table
+    def create_long_snippet(self,item):
         col_span_val = '"6"'
         snippet = CodeSnippet(self.code_snippets(), item,
                               pre=f"<tr> <td colspan={col_span_val}>",
                               post="</td></tr>")
         return snippet.place_code()
 
-    # Used for creating code snipets for Lie type representations
-    def create_lie_type_snippet(self,item):
+    # Used for displaying (short) code snippets in the constructions table
+    # e.g. for Lie type representations or transitive groups
+    def create_short_snippet(self,item):
         snippet = CodeSnippet(self.code_snippets(), item)
         return snippet.place_code()
 
     @lazy_attribute
     def lie_representations(self):
-        # Ideally we should get the Lie-type representations from the "gps_special_names" table:
+        """
+        Return a dictionary of Lie representations for the group
+        This uses our new conventions for matrix Lie groups
+
+        E.g. here the general sympletic group has the name "GSp" (and not "CSp")
+        and the general orthogonal group has the name "GOrth" (and not "CO")
+        """
+
+        # Ideally we should get the Lie-type representations from the "gps_special_names" table (once data has been updated)
         # lie_reps = list(db.gps_special_names.search({'label':self.label}, projection={'family','gens','parameters'}))
 
         # TODO: We should update groups data to use new family names
@@ -2883,8 +2898,239 @@ def lie_representations(self):
             return lie_reps
         return None
 
+    def create_top_code_snippet(self, code, top_lie, used_lie_gens):
+        """
+        Creates a top code snippet to construct the abstract group in Magma/GAP/SageMath/Oscar.
+        Stored as a dictionary in code['code_description']
+        """
+
+        # For each abstract group, we construct the (perhaps subjectively?) "best" implementation of this group as a code snippet
+        # in each language Magma/GAP/SageMath/Oscar, to display at the top of each abstract group page.
+        # This is computed and stored as a dictionary in code['code_description'].
+
+        # We first check if the group is a member of a special family.
+        # i.e. we check the following, in priority order: Cyclic, Symmetric, Dihedral, Alternating, Dicyclic, LieType, Chevalley.
+        # If the group is in such a family, then we give the code snippet corresponding to that particular family.
+        # Otherwise, if group is in GAP SmallGroups database, we use SmallGroup.
+        # Otherwise, if group is abelian, we use AbelianGroup, constructed from the primary invariants.
+
+        # If none of the above apply, we will default to showing one of the built-in code snippet constructions for the group.
+        # i.e. we check the following, in priority order: Perm, PC, or a matrix group constructions: GLZ, GLFp, GLZN, GLZq, or GLFq.
+
+        code['code_description'] = {'comment':"Construction of abstract group"}
+        self_families = []
+
+        # Highest priority: Check if group is cyclic
+        if self.cyclic:
+            for lang in code['cyclic_group']:
+                code['code_description'][lang] = code['cyclic_group'][lang].format(**{'ordgp':self.order})
+            return
+
+        # Check if group is symmetric
+        if self.name[0] == 'S' and self.name[1:].isdigit():
+            for lang in code['symmetric_group']:
+                code['code_description'][lang] = code['symmetric_group'][lang].format(**{'symn':self.name[1:]})
+            return
+
+        # Check if group is dihedral
+        if self.dihedral:
+            for lang in code['dihedral_group']:
+                code['code_description'][lang] = code['dihedral_group'][lang].format(**{'ordgp':self.order, 'ordgp_half':self.order//2})
+            return
+
+        # Check if group is alternating
+        if self.name[0] == 'A' and self.name[1:].isdigit():
+            for lang in code['alternating_group']:
+                code['code_description'][lang] = code['alternating_group'][lang].format(**{'altn':self.name[1:]})
+            return
+
+        # Otherwise, we must make a query to the database: gps_special_names (to obtain the families this group lies in)
+        self_families = list(db.gps_special_names.search({'label':self.label}, projection={'family','parameters'}))
+
+        # Check if group is dicyclic
+        if 'Dic' in [t['family'] for t in self_families]:
+            for lang in code['dicyclic_group']:
+                code['code_description'][lang] = code['dicyclic_group'][lang].format(**{'ordgp':self.order, 'ordgp_quarter':self.order//4})
+            return
+
+        for lang in code['prompt']:
+            # Use a Lie Type matrix construction (if it exists and the Lie type generators were not used)
+            if (top_lie[lang] is not None) and (not used_lie_gens[lang]):
+                code['code_description'][lang] = top_lie[lang]
+                continue
+
+            # Check if group is in the Chevalley family
+            if 'Chev' in [t['family'] for t in self_families]:
+                if lang in code['chevalley_group']:
+                    chev_index = [t['family'] for t in self_families].index("Chev")
+                    chev_params = str(self_families[chev_index]['parameters']['n'])+", "+str(self_families[chev_index]['parameters']['q'])
+                    chev_data = {'chev_fam': self_families[chev_index]['parameters']['fam'], 'chev_params': chev_params}
+                    code['code_description'][lang] = code['chevalley_group'][lang].format(**chev_data)
+                    continue
+
+            # Checking if group is in the Twisted Chevalley family
+            if 'TwistChev' in [t['family'] for t in self_families]:
+                if lang in code['chevalley_group']:
+                    chev_index = [t['family'] for t in self_families].index("TwistChev")
+                    chev_params = str(self_families[chev_index]['parameters']['n'])+", "+str(self_families[chev_index]['parameters']['q'])
+                    chev_data = {'chev_fam': str(self_families[chev_index]['parameters']['twist'])+self_families[chev_index]['parameters']['fam'], 'chev_params': chev_params}
+                    code['code_description'][lang] = code['chevalley_group'][lang].format(**chev_data)
+                    continue
+
+            # Check if in small groups GAP database (can then define the group G in Magma/Gap/Oscar)
+            if (self.label.split('.')[1].isdigit()):
+                gap_id = self.label.split('.')
+                if lang in code['small_group']:
+                    code['code_description'][lang] = code['small_group'][lang].format(**{'ordgp':self.order, 'gap_id':gap_id[1]})
+                    continue
+                
+            # Check if group is abelian (then can define as product of cyclic groups from its primary decomposition)
+            if self.abelian:
+                # Sage/Oscar's implementation of AbelianGroup seems to not support most of the usual group functions (probably better to not add this?)
+                if (lang in code['abelian_group']) and (lang not in ['sage', 'oscar']):
+                    code['code_description'][lang] = code['abelian_group'][lang].format(**{'abelian_invariants':self.primary_abelian_invariants})
+                    continue
+               
+            # Otherwise, if the group is not in a special family, we will default to showing one of the built-in group constructions
+            # (if it exists and is implemented)
+            # Highest priority: Permutation group, then PC group, then a matrix group, I guess?
+            for rep in ["Perm", "PC", "GLZ", "GLFp", "GLZN", "GLZq", "GLFq"]:
+                if rep in self.representations:
+                    # Get the corresponding name of the code snippet in the code.yaml file, for this representation
+                    if rep == "Perm":
+                        code_rep = "permutation"
+                    elif rep == "PC":
+                        code_rep = "presentation"
+                    else:
+                        code_rep = rep
+                    if lang in code[code_rep]:
+                        code['code_description'][lang] = code[code_rep][lang]
+                        break
+
+            # Finally, try using Lie constructions which required use of the generators
+            if (top_lie[lang] is not None) and (lang not in code['code_description']):
+                code['code_description'][lang] = top_lie[lang]
+
+        # Otherwise, if absolutely all else fails, we display no code snippet at the top :(
+        return
+
+    def create_lie_code_snippets(self, code, top_lie, used_lie_gens):
+        """
+        Creates code snippets for the Lie type representations in Magma/GAP/SageMath/Oscar.   
+        Each Lie representation is stored as a dictionary in the format code[(lie_family, n, q)]
+
+        For details on how the code logic works, see https://github.com/LMFDB/lmfdb/pull/6694
+
+        For the purposes of the code download command links, all Lie representations are also
+        all stored together in code["lie_reps_all"]
+        """
+
+        code["lie_reps_all"] = {lang:"" for lang in code['prompt']}
+        code["lie_reps_all"]['comment'] = "Define group as Lie representations"
+
+        if self.lie_representations is not None:
+            # Get Magma commands for all the Lie type families
+            gps_families_data = list(db.gps_families.search(projection={'family','magma_cmd'}))
+            magma_commands = {d['family']: d['magma_cmd'] for d in gps_families_data}
+
+            # Hardcoded list of Lie Type families available in GAP, Sage and Oscar  (NB: Must ensure their implementation agrees with our definition!)
+            families = dict()
+            families['gap'] = ['GL','SL','PSL','PGL','Sp','SO','SU','PSp','PSO','PSU','Orth','Unitary','Omega','PO','PU','POmega','PGammaL','PSigmaL']
+            families['sage'] = ['GL','SL','PSL','PGL','Sp','SO','SU','PSp','PSU','Orth','Unitary','PU']
+            families['oscar'] = ['GL','SL','Sp','SO','SU','Orth','Unitary']
+
+            # Prioritise displaying the first Lie type representation which is implemented in the language
+            for lie_rep in self.lie_representations:
+                nLie, qLie = ZZ(lie_rep['d']), ZZ(lie_rep['q'])
+                lie_rep_key = (lie_rep['family'], nLie, qLie)
+                code[lie_rep_key] = dict()
+
+                # For Magma, we always have a code snippet implemented for all possible Lie representations
+                code[lie_rep_key]['magma'] = "G := "+magma_commands[lie_rep['family']].replace("n,q", str(nLie)+","+str(qLie))+";"
+                code["lie_reps_all"]['magma'] += code[lie_rep_key]['magma']+"\n"
+                if top_lie['magma'] is None:
+                    top_lie['magma'] = code[lie_rep_key]['magma']
+    
+                for lang in ['gap', 'sage', 'oscar']:
+                    if lie_rep['family'] in families[lang]:
+                        code[lie_rep_key][lang] = code[lie_rep_key]['magma'] if lang == 'gap' else "G = "+magma_commands[lie_rep['family']].replace("n,q", str(nLie)+","+str(qLie))
+                        code["lie_reps_all"][lang] += code[lie_rep_key][lang]+"\n"
+                        if (top_lie[lang] is None) or used_lie_gens[lang]:
+                            top_lie[lang] = code[lie_rep_key][lang]
+                            used_lie_gens[lang] = False
+                    elif "gens" in lie_rep:
+                        lie_mats = [self.decode_as_matrix(g, "Lie", ListForm=True) for g in lie_rep["gens"]]
+
+                        if qLie.is_prime():
+                            # Construct Lie code snippets using the GLFp code snippet commands
+                            e = libgap.One(GF(qLie))
+                            LFpsplit = [split_matrix_list_Fp(mat, nLie, e) for mat in lie_mats]
+                            LFpsage = "["+", ".join(["MS("+str(split_matrix_list(mat, nLie))+")" for mat in lie_mats])+"]"
+                            LFposcar = "["+", ".join(["matrix(GF("+str(qLie)+"), "+str(split_matrix_list(mat, nLie))+")" for mat in lie_mats])+"]"
+                            lie_data = {'LFpsplit':LFpsplit, 'LFpsage':LFpsage, 'LFposcar':LFposcar, 'nFp':nLie, 'Fp':qLie}
+                            lie_code_snippet = code['GLFp'][lang].format(**lie_data)
+                        else:
+                            # Construct Lie code snippets using the GLFq code snippet commands
+                            LFqsplit = "[" + ",".join(split_matrix_list_Fq(mat, nLie, qLie) for mat in lie_mats) + "]"
+                            LFqsage = "["+", ".join(["MS("+str(split_matrix_Fq_add_al(mat, nLie))+")" for mat in lie_mats])+"]"
+                            LFqoscar = "["+", ".join(["matrix(GF("+str(qLie)+"), "+str(split_matrix_Fq_add_al(mat, nLie))+")" for mat in lie_mats])+"]"
+                            lie_data = {'LFqsplit':LFqsplit, 'LFqsage':LFqsage, 'LFqoscar':LFqoscar, 'nFq':nLie, 'Fq':qLie}
+                            lie_code_snippet = code['GLFq']['sage'].format(**lie_data)
+
+                        if top_lie[lang] is None:
+                            top_lie[lang], used_lie_gens[lang] = lie_code_snippet, True
+    
+            # In the case no Lie type representation is implemented natively in Sage or GAP, we display the first one with gens as a matrix group
+            # as a code snippet in the "Constructions" header (and as a possible candidate for the top code snippet)
+            for lang in code['prompt']:
+                if (top_lie[lang] is not None) and used_lie_gens[lang]:
+                    for lie_rep in self.lie_representations:
+                        if "gens" in lie_rep:
+                            lie_rep_key = (lie_rep['family'], ZZ(lie_rep['d']), ZZ(lie_rep['q']))
+                            code[lie_rep_key][lang] = top_lie[lang]
+                            code["lie_reps_all"][lang] += code[lie_rep_key][lang]+"\n"
+                            break
+
+        # If no Lie representation can be implemented in a given language lang, remove lang from code["lie_reps_all"]
+        for lang in code['prompt']:
+            if code["lie_reps_all"][lang] == '':
+                code["lie_reps_all"].pop(lang, None)
+
+    def create_transitive_code_snippets(self, code):
+        """
+        Creates code snippets for the transitive group representations   
+        Each representation is stored as a dictionary in the format code[trans_label]
+
+        For the purposes of the code download command links, all the transitive group representations
+        are also all stored together in code["transitive_all"]
+        """
+
+        code["transitive_all"] = {lang:"" for lang in code['prompt']}
+        code["transitive_all"]['comment'] = code["transitive"]["comment"]
+        
+        for trans in self.transitive_friends:
+            trans_data = {"deg":trans.split('T')[0], "t":trans.split('T')[1]}
+            code[trans] = dict()
+
+            for lang in code['prompt']:
+
+                # Oscar currently gives error for "transitive_group(1, 1)"  (can remove once fixed)
+                if (trans == "1T1") and (lang == "oscar"):
+                    continue
+
+                code[trans][lang] = code["transitive"][lang].format(**trans_data)
+                code["transitive_all"][lang] += code[trans][lang]+"\n"
+
+        for lang in code['prompt']:
+            if code["transitive_all"][lang] == '':
+                code["transitive_all"].pop(lang, None)
+
     @cached_method
     def code_snippets(self):
+        """ 
+        Constructs a dictionary of code snippets for the group
+        """
+
         if self.live():
             return
         _curdir = os.path.dirname(os.path.abspath(__file__))
@@ -2900,6 +3146,7 @@ def code_snippets(self):
             magma_assign = create_magma_assignment(self)
             sage_gap_assign = create_sage_gap_assignment(self.representations["PC"]["gens"])
         else:
+            code['presentation'] = {}
             gens, pccodelist, pccode, ordgp, used_gens, gap_assign, magma_assign, sage_gap_assign = None, None, None, None, None, None, None, None
         if "Perm" in self.representations:
             rdata = self.representations["Perm"]
@@ -2907,40 +3154,45 @@ def code_snippets(self):
             perms_sage = "'"+("', '".join(self.decode_as_perm(g, as_str=True) for g in rdata["gens"]))+"'"
             deg = rdata["d"]
         else:
+            code['permutation'] = {}
             perms, perms_sage, deg = None, None, None
 
         if "GLZ" in self.representations:
             nZ = self.representations["GLZ"]["d"]
             LZ = [self.decode_as_matrix(g, "GLZ", ListForm=True) for g in self.representations["GLZ"]["gens"]]
-            LZsplit = [split_matrix_list(self.decode_as_matrix(g, "GLZ", ListForm=True),nZ) for g in self.representations["GLZ"]["gens"]]
-            LZsage = "["+", ".join(["MS("+str(split_matrix_list(self.decode_as_matrix(g, "GLZ", ListForm=True),nZ))+")" for g in self.representations["GLZ"]["gens"]])+"]"
+            LZsplit = [split_matrix_list(mat,nZ) for mat in LZ]
+            LZsage = "["+", ".join(["MS("+str(split_matrix_list(mat,nZ))+")" for mat in LZ])+"]"
+            LZoscar = "["+", ".join(["matrix(ZZ, "+str(split_matrix_list(mat,nZ))+")" for mat in LZ])+"]"
         else:
-            nZ, LZ, LZsplit, LZsage = None, None, None, None
+            nZ, LZ, LZsplit, LZsage, LZoscar = None, None, None, None, None
         if "GLFp" in self.representations:
             nFp = self.representations["GLFp"]["d"]
             Fp = self.representations["GLFp"]["p"]
             LFp = [self.decode_as_matrix(g, "GLFp", ListForm=True) for g in self.representations["GLFp"]["gens"]]
             e = libgap.One(GF(Fp))
             LFpsplit = [split_matrix_list_Fp(A,nFp,e) for A in LFp]
-            LFpsage = "["+", ".join(["MS("+str(split_matrix_list(self.decode_as_matrix(g, "GLFp", ListForm=True),nFp))+")" for g in self.representations["GLFp"]["gens"]])+"]"
+            LFpsage = "["+", ".join(["MS("+str(split_matrix_list(mat,nFp))+")" for mat in LFp])+"]"
+            LFposcar = "["+", ".join(["matrix(GF("+str(Fp)+"), "+str(split_matrix_list(mat,nFp))+")" for mat in LFp])+"]"
         else:
-            nFp, Fp, LFp, LFpsplit, LFpsage = None, None, None, None, None
+            nFp, Fp, LFp, LFpsplit, LFpsage, LFposcar = None, None, None, None, None, None
         if "GLZN" in self.representations:
             nZN = self.representations["GLZN"]["d"]
             N = self.representations["GLZN"]["p"]
             LZN = [self.decode_as_matrix(g, "GLZN", ListForm=True) for g in self.representations["GLZN"]["gens"]]
             LZNsplit = "[" + ",".join(split_matrix_list_ZN(mat, nZN, N) for mat in LZN) + "]"
-            LZNsage = "["+", ".join(["MS("+str(split_matrix_list(self.decode_as_matrix(g, "GLZN", ListForm=True),nZN))+")" for g in self.representations["GLZN"]["gens"]])+"]"
+            LZNsage = "["+", ".join(["MS("+str(split_matrix_list(mat,nZN))+")" for mat in LZN])+"]"
+            LZNoscar = "["+", ".join(["matrix(residue_ring(ZZ, "+str(N)+")[1]"+str(split_matrix_list(mat,nZN))+")" for mat in LZN])+"]"
         else:
-            nZN, N, LZN, LZNsplit, LZNsage = None, None, None, None, None
+            nZN, N, LZN, LZNsplit, LZNsage, LZNoscar = None, None, None, None, None, None
         if "GLZq" in self.representations:
             nZq = self.representations["GLZq"]["d"]
             Zq = self.representations["GLZq"]["q"]
             LZq = [self.decode_as_matrix(g, "GLZq", ListForm=True) for g in self.representations["GLZq"]["gens"]]
-            LZqsplit = "[" + ",".join([split_matrix_list_ZN(self.decode_as_matrix(g, "GLZq", ListForm=True) , nZq, Zq) for g in self.representations["GLZq"]["gens"]]) + "]"
-            LZqsage = "["+", ".join(["MS("+str(split_matrix_list(self.decode_as_matrix(g, "GLZq", ListForm=True), nZq))+")" for g in self.representations["GLZq"]["gens"]])+"]"
+            LZqsplit = "[" + ",".join([split_matrix_list_ZN(mat, nZq, Zq) for mat in LZq]) + "]"
+            LZqsage = "["+", ".join(["MS("+str(split_matrix_list(mat, nZq))+")" for mat in LZq])+"]"
+            LZqoscar = "["+", ".join(["matrix(residue_ring(ZZ, "+str(Zq)+")[1]"+str(split_matrix_list(mat, nZq))+")" for mat in LZq])+"]"
         else:
-            nZq, Zq, LZq, LZqsplit, LZqsage = None, None, None, None, None
+            nZq, Zq, LZq, LZqsplit, LZqsage, LZqoscar, = None, None, None, None, None, None
         # add below for GLFq implementation
         if "GLFq" in self.representations:
             nFq = self.representations["GLFq"]["d"]
@@ -2949,8 +3201,9 @@ def code_snippets(self):
             LFq = ",".join(split_matrix_Fq_add_al(mat, nFq ) for mat in mats)
             LFqsplit = "[" + ",".join(split_matrix_list_Fq(mat, nFq, Fq) for mat in mats) + "]"
             LFqsage = "["+", ".join(["MS("+str(split_matrix_Fq_add_al(mat, nFq))+")" for mat in mats])+"]"
+            LFqoscar = "["+", ".join(["matrix(GF("+str(Fq)+"), "+str(split_matrix_Fq_add_al(mat, nFq))+")" for mat in mats])+"]"
         else:
-            nFq, Fq, LFq, LFqsplit, LFqsage = None, None, None, None, None
+            nFq, Fq, LFq, LFqsplit, LFqsage, LFqoscar = None, None, None, None, None, None
 
         data = {'gens' : gens, 'pccodelist': pccodelist, 'pccode': pccode,
                 'ordgp': ordgp, 'used_gens': used_gens, 'gap_assign': gap_assign, 'sage_gap_assign': sage_gap_assign,
@@ -2960,167 +3213,30 @@ def code_snippets(self):
                 'LZ': LZ, 'LFp': LFp, 'LZN': LZN, 'LZq': LZq, 'LFq': LFq,
                 'LZsplit': LZsplit, 'LZNsplit': LZNsplit, 'LZqsplit': LZqsplit,
                 'LFpsplit': LFpsplit, 'LFqsplit': LFqsplit, # add for GLFq GAP
-                # Adding the Sage versions of the matrix group code snippets:
+                # Adding the Sage/Oscar versions of the matrix group code snippets:
                 'LZsage': LZsage, 'LFpsage': LFpsage, 'LZNsage': LZNsage, 'LZqsage': LZqsage, 'LFqsage': LFqsage,
+                'LZoscar': LZoscar, 'LFposcar': LFposcar, 'LZNoscar': LZNoscar, 'LZqoscar': LZqoscar, 'LFqoscar': LFqoscar,
+                'symn': None, 'altn': None, 'ordgp_half': None, 'ordgp_quarter': None, 'chev_fam': None,
+                'chev_params': None, 'gap_id': None, 'abelian_invariants': None, 't': None
         }
 
-        # The following code implements code snippets for the Lie-type matrix representations
-        magma_top_lie, gap_top_lie, sage_top_lie = None, None, None   # Keep track of Lie-type snippet for use as a top code snippet
-        gap_used_lie_gens, sage_used_lie_gens = False, False          # Track whether we need to use generators
-        if self.lie_representations is not None:
-            # Get Magma commands for all the Lie type families
-            gps_families_data = list(db.gps_families.search(projection={'family','magma_cmd'}))
-            magma_commands = {d['family']: d['magma_cmd'] for d in gps_families_data}
-            # Hardcoded list of Lie Type families available in GAP and Sage  (NB: Must ensure their implementation agrees with our definition!)
-            gap_families = ['GL','SL','PSL','PGL','Sp','SO','SU','PSp','PSO','PSU','Orth','Unitary','Omega','PO','PU','POmega','PGammaL','PSigmaL']
-            sage_families = ['GL','SL','PSL','PGL','PSp','PSU','Orth','Unitary','PU']
+        # Construct code snippets for the Lie-type matrix representations
+        top_lie = {lang : None for lang in code['prompt']}                 # Keep track of Lie-type snippet for use as a top code snippet
+        used_lie_gens = {lang : False for lang in code['prompt']}          # Track whether we need to use generators
+        self.create_lie_code_snippets(code, top_lie, used_lie_gens)
 
-            # Prioritise displaying the first Lie type representation which is implemented in the language
-            for lie_rep in self.lie_representations:
-                nLie, qLie = ZZ(lie_rep['d']), ZZ(lie_rep['q'])
-                lie_rep_key = (lie_rep['family'], nLie, qLie)
-                code[lie_rep_key] = dict()
+        # Remove representations not implemented for this group (so that the code snippet command download links work)
+        for rep in ['GLZ', 'GLFp', 'GLZN', 'GLZq', 'GLFq']:
+            if rep not in self.representations:
+                code[rep] = {}
+            
+        # Construct code snippets for transitive groups
+        self.create_transitive_code_snippets(code)
 
-                code[lie_rep_key]['magma'] = "G := "+magma_commands[lie_rep['family']].replace("n,q", str(nLie)+","+str(qLie))+";"
-                if magma_top_lie is None:
-                    magma_top_lie = code[lie_rep_key]['magma']
-
-                if lie_rep['family'] in gap_families:
-                    code[lie_rep_key]['gap'] = code[lie_rep_key]['magma']
-                    if (gap_top_lie is None) or gap_used_lie_gens:
-                        gap_top_lie = code[lie_rep_key]['gap']
-                        gap_used_lie_gens = False
-                elif "gens" in lie_rep:
-                    lie_mats = [self.decode_as_matrix(g, "Lie", ListForm=True) for g in lie_rep["gens"]]
-                    if qLie.is_prime():
-                        e = libgap.One(GF(qLie))
-                        lie_gap_mats = [split_matrix_list_Fp(mat, nLie, e) for mat in lie_mats]
-                        gap_lie_code_snippet = code['GLFp']['gap'].format(**{'LFpsplit':lie_gap_mats})
-                    else:
-                        lie_gap_mats = "[" + ",".join(split_matrix_list_Fq(mat, nLie, qLie) for mat in lie_mats) + "]"
-                        gap_lie_code_snippet = code['GLFq']['gap'].format(**{'LFqsplit':lie_gap_mats})
-                    if gap_top_lie is None:
-                        gap_top_lie, gap_used_lie_gens = gap_lie_code_snippet, True
-
-                if lie_rep['family'] in sage_families:
-                    code[lie_rep_key]['sage'] = "G = "+magma_commands[lie_rep['family']].replace("n,q", str(nLie)+","+str(qLie))
-                    if (sage_top_lie is None) or sage_used_lie_gens:
-                        sage_top_lie = code[lie_rep_key]['sage']
-                        sage_used_lie_gens = False
-                elif "gens" in lie_rep:
-                    lie_mats = [self.decode_as_matrix(g, "Lie", ListForm=True) for g in lie_rep["gens"]]
-                    if qLie.is_prime():
-                        lie_sage_mats = "["+", ".join(["MS("+str(split_matrix_list(self.decode_as_matrix(g, "Lie", ListForm=True),nLie))+")" for g in lie_rep["gens"]])+"]"
-                        sage_lie_code_snippet = code['GLFp']['sage'].format(**{'LFpsage':lie_sage_mats, 'nFp':nLie, 'Fp':qLie})
-                    else:
-                        lie_sage_mats = "["+", ".join(["MS("+str(split_matrix_Fq_add_al(mat, nLie))+")" for mat in lie_mats])+"]"
-                        sage_lie_code_snippet = code['GLFq']['sage'].format(**{'LFqsage':lie_sage_mats, 'nFq':nLie, 'Fq':qLie})
-                    if sage_top_lie is None:
-                        sage_top_lie, sage_used_lie_gens = sage_lie_code_snippet, True
-
-        # In the case no Lie type representation is implemented natively in Sage or GAP, we display the first one with gens as a matrix group
-        # as a code snippet in the "Constructions" header (and as a possible candidate for the top code snippet)
-        if (gap_top_lie is not None) and gap_used_lie_gens:
-            for lie_rep in self.lie_representations:
-                if "gens" in lie_rep:
-                    code[(lie_rep['family'],lie_rep['d'],lie_rep['q'])]['gap'] = gap_top_lie
-                    break
-        if (sage_top_lie is not None) and sage_used_lie_gens:
-            for lie_rep in self.lie_representations:
-                if "gens" in lie_rep:
-                    code[(lie_rep['family'],lie_rep['d'],lie_rep['q'])]['sage'] = sage_top_lie
-                    break
-
-        # Here, we add the (perhaps subjectively?) "best" implementation of this group as a code snippet in Magma/GAP/SageMath,
-        # to display at the top of each group page.  This is computed and stored in code['code_description'].
-        # If the group is a member of a special family (i.e. Cyclic,Symmetric,Dihedral,Alternating,Dicyclic,LieType,Chevalley),
-        # then we give the code for that family.  Otherwise, if abelian, we use AbelianGroup, or otherwise use SmallGroup (if in GAP db)
-        # If none of the above apply, we will default to showing one of the built-in code snippet constructions for the group
-        # (i.e. either Perm, PC, or one of the matrix group constructions: GLZ, GLFp, GLZN, GLZq, or GLFq )
-        # TODO: I realize this big lump of code does seem somewhat hacky. Should ideally somehow implement this through the code.yaml file
-        code['code_description'] = dict()
-        self_families = []
-        # Highest priority: check if group is cyclic
-        if self.cyclic:
-            for lang in ['magma', 'gap']:
-                code['code_description'][lang] = "G := CyclicGroup("+str(self.order)+");"
-            code['code_description']['sage'] = "G = CyclicPermutationGroup("+str(self.order)+")"
-        # Check if symmetric
-        elif self.name[0] == 'S' and self.name[1:].isdigit():
-            for lang in ['magma', 'gap']:
-                code['code_description'][lang] = "G := SymmetricGroup("+self.name[1:]+");"
-            code['code_description']['sage'] = "G = SymmetricGroup("+self.name[1:]+")"
-        # Check if dihedral
-        elif self.dihedral:
-            code['code_description']['magma'] = "G := DihedralGroup("+str(self.order/2)+");" # Magma D(n) has order 2n
-            code['code_description']['gap'] = "G := DihedralGroup("+str(self.order)+");"     # GAP D(n) has order n
-            code['code_description']['sage'] = "G = DihedralGroup("+str(self.order/2)+")"    # Sage D(n) has order 2n
-        # Check if alternating
-        elif self.name[0] == 'A' and self.name[1:].isdigit():
-            for lang in ['magma', 'gap']:
-                code['code_description'][lang] = "G := AlternatingGroup("+self.name[1:]+");"
-            code['code_description']['sage'] = "G = AlternatingGroup("+self.name[1:]+")"
-        else:
-            # Otherwise, we must make a query to the database: gps_special_names  (to obtain the families this group lies in)
-            self_families = list(db.gps_special_names.search({'label':self.label}, projection={'family','parameters'}))
-            if 'Dic' in [t['family'] for t in self_families]:
-                code['code_description']['magma'] = "G := DicyclicGroup("+str(self.order/4)+");" # Magma Dic(n) has order 4n
-                code['code_description']['gap'] = "G := DicyclicGroup("+str(self.order)+");"     # GAP Dic(n) has order n
-                code['code_description']['sage'] = "G = DiCyclicGroup("+str(self.order/4)+")"    # Sage Dic(n) has order 4n
-            else:
-                # Use a Lie Type matrix construction (if it exists and the Lie type generators were not used)
-                if magma_top_lie is not None:
-                    code['code_description']['magma'] = magma_top_lie
-                if (gap_top_lie is not None) and (not gap_used_lie_gens):
-                    code['code_description']['gap'] = gap_top_lie
-                if (sage_top_lie is not None) and (not sage_used_lie_gens):
-                    code['code_description']['sage'] = sage_top_lie
-        # Checking if group is in the Chevalley or Twisted Chevalley family
-        if ('Chev' in [t['family'] for t in self_families]) and ('magma' not in code['code_description']):
-            chev_index = [t['family'] for t in self_families].index("Chev")
-            chev_params = str(self_families[chev_index]['parameters']['n'])+", "+str(self_families[chev_index]['parameters']['q'])
-            code['code_description']['magma'] = 'G := ChevalleyGroup("'+self_families[chev_index]['parameters']['fam']+'", '+chev_params+");"
-        if ('TwistChev' in [t['family'] for t in self_families]) and ('magma' not in code['code_description']):
-            chev_index = [t['family'] for t in self_families].index("TwistChev")
-            chev_params = str(self_families[chev_index]['parameters']['n'])+", "+str(self_families[chev_index]['parameters']['q'])
-            code['code_description']['magma'] = 'G := ChevalleyGroup("'+str(self_families[chev_index]['parameters']['twist'])+self_families[chev_index]['parameters']['fam']+'", '+chev_params+");"
-        # Otherwise, check if in small groups database (can then define the group G in Magma and Gap)
-        if (self.label.split('.')[1].isdigit()):
-            gap_id = self.label.split('.')
-            for lang in ['magma', 'gap']:
-                if lang not in code['code_description']:
-                    code['code_description'][lang] = 'G := SmallGroup('+gap_id[0]+', '+gap_id[1]+');'
-            if 'sage_gap' not in code['code_description']:
-                code['code_description']['sage_gap'] = 'G = libgap.SmallGroup('+gap_id[0]+', '+gap_id[1]+')'
-        # Otherwise, check if group is abelian (then can define as product of cyclic groups from its primary decomposition)
-        if self.abelian:
-            for lang in ['magma', 'gap']:
-                if lang not in code['code_description']:
-                    code['code_description'][lang] = 'G := AbelianGroup('+str(self.primary_abelian_invariants)+');'
-           # Sage's implementation of AbelianGroup seems to not support most of the usual group functions (probably better to not add this?)
-           #if 'sage' not in code['code_description']: code['code_description']['sage'] = 'G = AbelianGroup('+str(self.primary_abelian_invariants)+')'
-        # If the group is not in a special family, we will default to showing one of the built-in group constructions (if it exists and is implemented)
-        # Highest  priority: Permutation group, then PC group, then a matrix group, I guess?
-        for rep in ["Perm", "PC", "GLZ", "GLFp", "GLZN", "GLZq", "GLFq"]:
-            if rep in self.representations:
-                # Get the corresponding name of the code snippet in the code.yaml file, for this representation
-                if rep == "Perm":
-                    code_rep = "permutation"
-                elif rep == "PC":
-                    code_rep = "presentation"
-                else:
-                    code_rep = rep
-                for lang in code[code_rep]:
-                    if lang not in code['code_description']:
-                        code['code_description'][lang] = code[code_rep][lang]
-        # Finally, try using Lie constructions which required use of the generators
-        if (gap_top_lie is not None) and ('gap' not in code['code_description']):
-            code['code_description']['gap'] = gap_top_lie
-        if (sage_top_lie is not None) and ('sage' not in code['code_description']):
-            code['code_description']['sage'] = sage_top_lie
-        # Otherwise, if absolutely all else fails, we display no code snippet at the top :(
+        # Construct the main top code snippet
+        self.create_top_code_snippet(code, top_lie, used_lie_gens)
 
-        # If no Sage top code snippet, then we resort to implementing the group G using the GAP interface in Sage
+        # If there is no Sage top code snippet, then we resort to implementing the group G using the GAP interface in Sage
         if ('sage' in code['code_description']) and ("gap" not in code['code_description']['sage']):
             code['prompt'].pop('sage_gap', None)
         else:
@@ -3160,8 +3276,9 @@ def code_snippets(self):
                 code['prompt'].pop(lang, None)
 
         for prop in code:
-            for lang in code[prop]:
-                code[prop][lang] = code[prop][lang].format(**data)
+            if prop not in ['frontmatter', 'snippet_test']:
+                for lang in code[prop]:
+                    code[prop][lang] = code[prop][lang].format(**data)
         return code
 
     # The following attributes are used in create_boolean_string
diff --git a/lmfdb/tests/generate_snippet_tests.py b/lmfdb/tests/generate_snippet_tests.py
index 2fe03e698f..85d54dec8f 100644
--- a/lmfdb/tests/generate_snippet_tests.py
+++ b/lmfdb/tests/generate_snippet_tests.py
@@ -22,11 +22,14 @@
 
 
 exec_dict = {'sage': 'sage --simple-prompt',
+             'sage_gap': 'sage --simple-prompt',   # Used for evaluating GAP-type group objects defined within Sage
              'magma': 'magma -b',
              'oscar': 'julia',
-             'gp': "sage -gp -D prompt='gp> ' -D breakloop=0 -D colors='no,no,no,no,no,no,no' -D readline=0 -q"}
-prompt_dict = {'sage': 'sage:', 'magma': 'magma> ', 'oscar': 'julia>', 'gp': 'gp> '}
-comment_dict = {'magma': '//', 'sage': '#',
+             'gp': "sage -gp -D prompt='gp> ' -D breakloop=0 -D colors='no,no,no,no,no,no,no' -D readline=0 -q",
+             'gap': """sage -gap -b -T -r -A -m 256m -o 512m -x 800 -c 'SetUserPreference("UseColorsInTerminal",false);'""",
+             }
+prompt_dict = {'sage': 'sage:', 'sage_gap': 'sage:',  'magma': 'magma> ', 'oscar': 'julia>', 'gp': 'gp> ', 'gap': 'gap> '}
+comment_dict = {'magma': '//', 'sage': '#',  'sage_gap': '#',
                          'gp': '\\\\', 'pari': '\\\\', 'oscar': '#', 'gap': '#'}
 
 
diff --git a/lmfdb/tests/snippet_tests/galois_groups/code-11T5-gap.log b/lmfdb/tests/snippet_tests/galois_groups/code-11T5-gap.log
new file mode 100644
index 0000000000..15c8c3c7e5
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/galois_groups/code-11T5-gap.log
@@ -0,0 +1,31 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+gap> G := TransitiveGroup(11, 5);
+L(11)=PSL(2,11)(11)
+gap> IdGroup(G);
+[ 660, 13 ]
+gap> Order(G);
+660
+gap> IsCyclic(G);
+false
+gap> IsAbelian(G);
+false
+gap> IsSolvable(G);
+false
+gap> if IsNilpotentGroup(G) then NilpotencyClassOfGroup(G); fi;
+gap> NrMovedPoints(G);
+11
+gap> TransitiveIdentification(G);
+5
+gap> ForAll(GeneratorsOfGroup(G), g -> SignPerm(g) = 1);
+true
+gap> IsPrimitive(G);
+true
+gap> Order(Centralizer(SymmetricGroup(11), G));
+1
+gap> GeneratorsOfGroup(G);
+[ (1,2,3,4,5,6,7,8,9,10,11), (2,10)(3,4)(5,9)(6,7) ]
+gap> ConjugacyClasses(G);
+[ ()^G, (3,4)(5,7)(6,9)(8,11)^G, (3,5,8)(4,11,7)(6,9,10)^G, (2,3,6,9,4)(5,10,7,8,11)^G, (2,3,10,9,7)(4,5,11,8,6)^G, (1,2)(3,4,8,7,5,11)(6,9,10)^G, (1,2,3,4,5,6,7,8,9,10,11)^G, (1,2,3,6,10,7,5,9,11,8,4)^G ]
+gap> CharacterTable(G);
+CharacterTable( L(11)=PSL(2,11)(11) )
+gap> 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/galois_groups/code-11T5-oscar.log b/lmfdb/tests/snippet_tests/galois_groups/code-11T5-oscar.log
index 4d1fa11c9f..a2e7b32312 100644
--- a/lmfdb/tests/snippet_tests/galois_groups/code-11T5-oscar.log
+++ b/lmfdb/tests/snippet_tests/galois_groups/code-11T5-oscar.log
@@ -3,6 +3,9 @@
 julia> G = transitive_group(11, 5)
 Permutation group of degree 11
 
+julia> small_group_identification(G)
+(660, 13)
+
 julia> order(G)
 660
 
diff --git a/lmfdb/tests/snippet_tests/galois_groups/code-11T5-sage.log b/lmfdb/tests/snippet_tests/galois_groups/code-11T5-sage.log
index a44172897c..6445cb24ad 100644
--- a/lmfdb/tests/snippet_tests/galois_groups/code-11T5-sage.log
+++ b/lmfdb/tests/snippet_tests/galois_groups/code-11T5-sage.log
@@ -23,7 +23,7 @@ True
 sage: SymmetricGroup(11).centralizer(G).order()
 1
 sage: G.gens()
-((1,2,3,4,5,6,7,8,9,10,11), (2,10)(3,4)(5,9)(6,7))
+((2,10)(3,4)(5,9)(6,7), (1,2,3,4,5,6,7,8,9,10,11))
 sage: G.conjugacy_classes()
 [Conjugacy class of () in Transitive group number 5 of degree 11,
  Conjugacy class of (3,4)(5,7)(6,9)(8,11) in Transitive group number 5 of degree 11,
diff --git a/lmfdb/tests/snippet_tests/galois_groups/code-4T2-gap.log b/lmfdb/tests/snippet_tests/galois_groups/code-4T2-gap.log
new file mode 100644
index 0000000000..a2fcf73c42
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/galois_groups/code-4T2-gap.log
@@ -0,0 +1,31 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+gap> G := TransitiveGroup(4, 2);
+E(4) = 2[x]2
+gap> IdGroup(G);
+[ 4, 2 ]
+gap> Order(G);
+4
+gap> IsCyclic(G);
+false
+gap> IsAbelian(G);
+true
+gap> IsSolvable(G);
+true
+gap> if IsNilpotentGroup(G) then NilpotencyClassOfGroup(G); fi;
+gap> NrMovedPoints(G);
+4
+gap> TransitiveIdentification(G);
+2
+gap> ForAll(GeneratorsOfGroup(G), g -> SignPerm(g) = 1);
+true
+gap> IsPrimitive(G);
+false
+gap> Order(Centralizer(SymmetricGroup(4), G));
+4
+gap> GeneratorsOfGroup(G);
+[ (1,4)(2,3), (1,2)(3,4) ]
+gap> ConjugacyClasses(G);
+[ ()^G, (1,2)(3,4)^G, (1,3)(2,4)^G, (1,4)(2,3)^G ]
+gap> CharacterTable(G);
+CharacterTable( E(4) = 2[x]2 )
+gap> 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/galois_groups/code-4T2-oscar.log b/lmfdb/tests/snippet_tests/galois_groups/code-4T2-oscar.log
index 3617b0da2e..35a37d861d 100644
--- a/lmfdb/tests/snippet_tests/galois_groups/code-4T2-oscar.log
+++ b/lmfdb/tests/snippet_tests/galois_groups/code-4T2-oscar.log
@@ -3,6 +3,9 @@
 julia> G = transitive_group(4, 2)
 Permutation group of degree 4
 
+julia> small_group_identification(G)
+(4, 2)
+
 julia> order(G)
 4
 
diff --git a/lmfdb/tests/snippet_tests/galois_groups/code-4T2-sage.log b/lmfdb/tests/snippet_tests/galois_groups/code-4T2-sage.log
index 33f8302642..76675ef085 100644
--- a/lmfdb/tests/snippet_tests/galois_groups/code-4T2-sage.log
+++ b/lmfdb/tests/snippet_tests/galois_groups/code-4T2-sage.log
@@ -23,7 +23,7 @@ False
 sage: SymmetricGroup(4).centralizer(G).order()
 4
 sage: G.gens()
-((1,4)(2,3), (1,2)(3,4))
+((1,2)(3,4), (1,4)(2,3))
 sage: G.conjugacy_classes()
 [Conjugacy class of () in Transitive group number 2 of degree 4,
  Conjugacy class of (1,2)(3,4) in Transitive group number 2 of degree 4,
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-A5-gap.log b/lmfdb/tests/snippet_tests/groups/abstract/code-A5-gap.log
new file mode 100644
index 0000000000..338a555d77
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-A5-gap.log
@@ -0,0 +1,147 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+gap> G := AlternatingGroup(5);
+Alt( [ 1 .. 5 ] )
+gap> Order(G);
+60
+gap> Exponent(G);
+30
+gap> AutomorphismGroup(G);
+<group of size 120 with 3 generators>
+gap> FactorGroup(AutomorphismGroup(G), InnerAutomorphismGroup(G));
+Group([ f1, <identity> of ..., <identity> of ... ])
+gap> CompositionSeries(G);
+[ Alt( [ 1 .. 5 ] ), Group(()) ]
+gap> if IsNilpotentGroup(G) then NilpotencyClassOfGroup(G); fi;
+gap> DerivedLength(G);
+0
+gap> IsAbelian(G);
+false
+gap> IsCyclic(G);
+false
+gap> IsElementaryAbelian(G);
+false
+gap> IsMonomialGroup(G);
+false
+gap> IsNilpotentGroup(G);
+false
+gap> IsPerfectGroup(G);
+true
+gap> IsPGroup(G);
+false
+gap> IsPolycyclicGroup(G);
+false
+gap> IsSimpleGroup(G);
+true
+gap> IsSolvableGroup(G);
+false
+gap> IsSupersolvableGroup(G);
+false
+gap> element_orders := List(Elements(G), g -> Order(g));
+[ 1, 3, 3, 2, 3, 3, 3, 3, 2, 3, 3, 2, 2, 2, 2, 3, 5, 5, 5, 3, 5, 5, 3, 5, 3, 5, 5, 2, 3, 3, 2, 5, 5, 2, 5, 5, 5, 3, 5, 3, 3, 2, 5, 2, 5, 5, 5, 2, 5, 3, 5, 3, 3, 2, 5, 2, 5, 5, 5, 2 ]
+gap> orders := Set(element_orders);
+[ 1, 2, 3, 5 ]
+gap> Print("Orders: ", orders, "\n");
+Orders: [ 1, 2, 3, 5 ]
+gap> element_counts := List(orders, n -> Length(Filtered(element_orders, x -> x = n)));
+[ 1, 15, 20, 24 ]
+gap> Print("Elements: ", element_counts, " ", Size(G), "\n");
+Elements: [ 1, 15, 20, 24 ] 60
+gap> cc_orders := List(ConjugacyClasses(G), cc -> Order(Representative(cc)));
+[ 1, 2, 3, 5, 5 ]
+gap> cc_counts := List(orders, n -> Length(Filtered(cc_orders, x -> x = n)));
+[ 1, 1, 1, 2 ]
+gap> Print("Conjugacy classes: ", cc_counts, " ", Length(ConjugacyClasses(G)), "\n");
+Conjugacy classes: [ 1, 1, 1, 2 ] 5
+gap> ConjugacyClasses(G);  # Output not guaranteed to exactly match the LMFDB table
+[ ()^G, (1,2)(3,4)^G, (1,2,3)^G, (1,2,3,4,5)^G, (1,2,3,5,4)^G ]
+gap> CharacterDegrees(G);
+[ [ 1, 1 ], [ 3, 2 ], [ 4, 1 ], [ 5, 1 ] ]
+gap> SL(2,4);
+SL(2,4)
+gap> PSL(2,4);
+Group([ (3,4,5), (1,2,3) ])
+gap> PSL(2,5);
+Group([ (3,5)(4,6), (1,2,5)(3,4,6) ])
+gap> PGL(2,4);
+Group([ (3,5,4), (1,2,3) ])
+gap> SO(3,4);
+GO(0,3,4)
+gap> SU(2,4);
+SU(2,4)
+gap> PSO(3,4);
+Group([ (3,4,5)(7,9,8)(10,14,18)(11,17,20)(12,15,21)(13,16,19), (1,2,11)(3,7,10)(4,19,12)(5,15,13)(8,14,21)(9,18,16) ])
+gap> PSU(2,4);
+Group([ (3,4,5)(6,10,14)(7,11,15)(8,12,16)(9,13,17), (1,2,3)(6,14,8)(7,11,10)(9,17,15)(12,16,13) ])
+gap> PSU(2,5);
+Group([ (3,5)(4,6)(7,17)(8,18)(9,19)(10,20)(11,21)(12,22)(13,23)(14,24)(15,25)(16,26), (1,2,14)(3,26,20)(4,25,16)(5,12,23)(6,8,22)(7,15,10)(9,19,24)(13,21,18) ])
+gap> GO(3,4);
+GO(0,3,4)
+gap> Omega(3,4);
+GO(0,3,4)
+gap> Omega(3,5);
+Omega(0,3,5)
+gap> PGO(3,4);
+Group([ (3,4,5)(7,9,8)(10,14,18)(11,17,20)(12,15,21)(13,16,19), (1,2,11)(3,7,10)(4,19,12)(5,15,13)(8,14,21)(9,18,16) ])
+gap> PGU(2,4);
+Group([ (3,5,4)(6,14,10)(7,15,11)(8,16,12)(9,17,13), (1,2,3)(6,14,8)(7,11,10)(9,17,15)(12,16,13) ])
+gap> POmega(3,4);
+Group([ (3,4,5)(7,9,8)(10,14,18)(11,17,20)(12,15,21)(13,16,19), (1,2,11)(3,7,10)(4,19,12)(5,15,13)(8,14,21)(9,18,16) ])
+gap> POmega(3,5);
+Group([ (1,7,20)(2,12,5)(3,27,31)(4,17,8)(6,22,24)(9,28,19)(10,14,21)(11,26,18)(13,23,30)(16,29,25), (3,5)(4,6)(12,22)(13,23)(14,24)(15,25)(16,26)(17,27)(18,28)(19,29)(20,30)(21,31) ])
+gap> PSigmaL(2,5);
+Group([ (3,5)(4,6), (1,2,5)(3,4,6) ])
+gap> Group( (1,2,3,4,5), (1,2,3) );
+Group([ (1,2,3,4,5), (1,2,3) ])
+gap> Group([[[1, 1, 1, 0], [0, -1, -1, 0], [0, 1, 0, 0], [0, 0, 1, 1]], [[0, 0, 0, 1], [0, -1, -1, -1], [0, 1, 0, 0], [-1, -1, 0, 0]]]);
+<matrix group with 2 generators>
+gap> Group([[[ Z(5), Z(5)^0, Z(5)^0 ], [ Z(5)^2, 0*Z(5), Z(5)^0 ], [ Z(5)^0, Z(5)^0, Z(5)^3 ]], [[ Z(5)^0, Z(5)^0, Z(5)^2 ], [ Z(5), 0*Z(5), Z(5)^2 ], [ Z(5), Z(5)^0, Z(5)^3 ]]]);
+Group([ [ [ Z(5), Z(5)^0, Z(5)^0 ], [ Z(5)^2, 0*Z(5), Z(5)^0 ], [ Z(5)^0, Z(5)^0, Z(5)^3 ] ], [ [ Z(5)^0, Z(5)^0, Z(5)^2 ], [ Z(5), 0*Z(5), Z(5)^2 ], [ Z(5), Z(5)^0, Z(5)^3 ] ] ])
+gap> TransitiveGroup(5, 4);
+A5
+gap> TransitiveGroup(6, 12);
+L(6) = PSL(2,5) = A_5(6)
+gap> TransitiveGroup(10, 7);
+A_5(10)
+gap> TransitiveGroup(12, 33);
+A_5(12)
+gap> TransitiveGroup(15, 5);
+A_5(15)
+gap> TransitiveGroup(20, 15);
+t20n15
+gap> TransitiveGroup(30, 9);
+t30n9
+gap> AbelianInvariants(G);
+[  ]
+gap> FactorGroup(G, DerivedSubgroup(G));
+Group(())
+gap> AbelianInvariantsMultiplier(G);
+[ 2 ]
+gap> CommutatorLength(G);
+1
+gap> AllSubgroups(G);
+[ Group(()), Group([ (2,3)(4,5) ]), Group([ (2,4)(3,5) ]), Group([ (2,5)(3,4) ]), Group([ (1,2)(4,5) ]), Group([ (1,2)(3,4) ]), Group([ (1,2)(3,5) ]), Group([ (1,3)(4,5) ]), Group([ (1,3)(2,4) ]), Group([ (1,3)(2,5) ]), Group([ (1,4)(3,5) ]), Group([ (1,4)(2,3) ]), 
+  Group([ (1,4)(2,5) ]), Group([ (1,5)(3,4) ]), Group([ (1,5)(2,3) ]), Group([ (1,5)(2,4) ]), Group([ (3,4,5) ]), Group([ (2,3,4) ]), Group([ (2,5,3) ]), Group([ (2,4,5) ]), Group([ (1,2,3) ]), Group([ (1,4,2) ]), Group([ (1,2,5) ]), Group([ (1,3,4) ]), Group([ (1,5,3) ]), Group([ (1,4,5) ]), Group([ (2,3)(4,5), (2,4)(3,5) ]), Group([ (1,2)(4,5), (1,4)(2,5) ]), Group([ (1,2)(3,4), (1,3)(2,4) ]), Group([ (1,5)(2,3), (1,3)(2,5) ]), Group([ (1,5)(3,4), (1,4)(3,5) ]), Group([ (1,2,3,4,5) ]), Group([ (1,5,2,4,3) ]), Group([ (1,2,4,5,3) ]), Group([ (1,4,5,2,3) ]), Group([ (1,4,2,3,5) ]), Group([ (1,2,5,3,4) ]), Group([ (1,2)(4,5), (3,4,5) ]), Group([ (2,3)(4,5), (1,2,3) ]), Group([ (1,5)(2,3), (1,4,5) ]), Group([ (1,5)(3,4), (2,3,4) ]), Group([ (1,4)(3,5), (2,5,3) ]), 
+  Group([ (1,3)(2,5), (2,4,5) ]), Group([ (2,4)(3,5), (1,4,2) ]), Group([ (1,3)(2,4), (1,5,3) ]), Group([ (1,2)(3,4), (1,2,5) ]), Group([ (1,4)(2,5), (1,3,4) ]), Group([ (1,5)(2,4), (1,4)(3,5) ]), Group([ (1,2)(3,5), (1,4)(2,5) ]), Group([ (1,3)(2,5), (1,5)(3,4) ]), Group([ (1,2)(3,4), (1,5)(2,3) ]), Group([ (1,3)(2,4), (1,2)(4,5) ]), Group([ (1,4)(2,3), (1,3)(4,5) ]), Group([ (3,4,5), (2,4)(3,5) ]), Group([ (1,4,5), (1,4)(3,5) ]), Group([ (2,3,4), (1,3)(2,4) ]), Group([ (1,2,3), (1,3)(2,5) ]), Group([ (1,2,5), (1,4)(2,5) ]), Group([ (2,4)(3,5), (1,2,5) ]) ]
+gap> Center(G);
+Group(())
+gap> DerivedSubgroup(G);
+Alt( [ 1 .. 5 ] )
+gap> FrattiniSubgroup(G);
+Group(())
+gap> FittingSubgroup(G);
+Group(())
+gap> SolvableRadical(G);
+Group(())
+gap> Socle(G);
+Alt( [ 1 .. 5 ] )
+gap> DerivedSeriesOfGroup(G);
+[ Alt( [ 1 .. 5 ] ) ]
+gap> ChiefSeries(G);
+[ Alt( [ 1 .. 5 ] ), Group(()) ]
+gap> LowerCentralSeriesOfGroup(G);
+[ Alt( [ 1 .. 5 ] ) ]
+gap> UpperCentralSeriesOfGroup(G);
+[ Group(()) ]
+gap> CharacterTable(G);  # Output not guaranteed to exactly match the LMFDB table
+CharacterTable( Alt( [ 1 .. 5 ] ) )
+gap> 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-A5-oscar.log b/lmfdb/tests/snippet_tests/groups/abstract/code-A5-oscar.log
new file mode 100644
index 0000000000..d84891de3d
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-A5-oscar.log
@@ -0,0 +1,243 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+
+julia> G = alternating_group(5)
+Alternating group of degree 5
+
+julia> order(G)
+60
+
+julia> exponent(G)
+30
+
+julia> automorphism_group(G)
+Automorphism group of
+  alternating group of degree 5
+
+julia> composition_series(G)
+2-element Vector{PermGroup}:
+ Alternating group of degree 5
+ Permutation group of degree 5 and order 1
+
+julia> if is_nilpotent(G) nilpotency_class(G) end
+
+julia> derived_length(G)
+0
+
+julia> is_abelian(G)
+false
+
+julia> is_cyclic(G)
+false
+
+julia> is_elementary_abelian(G)
+false
+
+julia> is_nilpotent(G)
+false
+
+julia> is_perfect(G)
+true
+
+julia> is_pgroup(G)
+false
+
+julia> is_simple(G)
+true
+
+julia> is_solvable(G)
+false
+
+julia> is_supersolvable(G)
+false
+
+julia> element_orders = [order(g) for g in elements(G)]
+60-element Vector{ZZRingElem}:
+ 1
+ 3
+ 3
+ 3
+ 2
+ 3
+ 3
+ 3
+ 2
+ 3
+ ⋮
+ 5
+ 5
+ 3
+ 5
+ 5
+ 2
+ 2
+ 5
+ 5
+
+julia> orders = sort(unique(element_orders))
+4-element Vector{ZZRingElem}:
+ 1
+ 2
+ 3
+ 5
+
+julia> println("Orders: ", orders)
+Orders: ZZRingElem[1, 2, 3, 5]
+
+julia> element_counts = [count(==(n), element_orders) for n in orders]
+4-element Vector{Int64}:
+  1
+ 15
+ 20
+ 24
+
+julia> println("Elements: ", element_counts, " ", order(G))
+Elements: [1, 15, 20, 24] 60
+
+julia> ccs = conjugacy_classes(G)
+5-element Vector{GAPGroupConjClass{PermGroup, PermGroupElem}}:
+ Conjugacy class of () in G
+ Conjugacy class of (1,2)(3,4) in G
+ Conjugacy class of (1,2,3) in G
+ Conjugacy class of (1,2,3,4,5) in G
+ Conjugacy class of (1,2,3,5,4) in G
+
+julia> cc_orders = [order(representative(cc)) for cc in ccs]
+5-element Vector{ZZRingElem}:
+ 1
+ 2
+ 3
+ 5
+ 5
+
+julia> cc_counts = [count(==(n), cc_orders) for n in orders]
+4-element Vector{Int64}:
+ 1
+ 1
+ 1
+ 2
+
+julia> println("Conjugacy classes: ", cc_counts, " ", length(ccs))
+Conjugacy classes: [1, 1, 1, 2] 5
+
+julia> conjugacy_classes(G)  # Output not guaranteed to exactly match the LMFDB table
+5-element Vector{GAPGroupConjClass{PermGroup, PermGroupElem}}:
+ Conjugacy class of () in G
+ Conjugacy class of (1,2)(3,4) in G
+ Conjugacy class of (1,2,3) in G
+ Conjugacy class of (1,2,3,4,5) in G
+ Conjugacy class of (1,2,3,5,4) in G
+
+julia> character_degrees(G)
+MSet{ZZRingElem} with 5 elements:
+  5
+  4
+  3 : 2
+  1
+
+julia> SL(2,4)
+SL(2,4)
+
+julia> SO(3,4)
+GO(3,4)
+
+julia> SU(2,4)
+SU(2,4)
+
+julia> GO(3,4)
+GO(3,4)
+
+julia> @permutation_group(5, (1,2,3,4,5), (1,2,3))
+Permutation group of degree 5
+
+julia> matrix_group([matrix(ZZ, [[1, 1, 1, 0], [0, -1, -1, 0], [0, 1, 0, 0], [0, 0, 1, 1]]), matrix(ZZ, [[0, 0, 0, 1], [0, -1, -1, -1], [0, 1, 0, 0], [-1, -1, 0, 0]])])
+Matrix group of degree 4
+  over integer ring
+
+julia> matrix_group([matrix(GF(5), [[2, 1, 1], [4, 0, 1], [1, 1, 3]]), matrix(GF(5), [[1, 1, 4], [2, 0, 4], [2, 1, 3]])])
+Matrix group of degree 3
+  over prime field of characteristic 5
+
+julia> transitive_group(5, 4)
+Alternating group of degree 5
+
+julia> transitive_group(6, 12)
+Permutation group of degree 6
+
+julia> transitive_group(10, 7)
+Permutation group of degree 10
+
+julia> transitive_group(12, 33)
+Permutation group of degree 12
+
+julia> transitive_group(15, 5)
+Permutation group of degree 15
+
+julia> transitive_group(20, 15)
+Permutation group of degree 20
+
+julia> transitive_group(30, 9)
+Permutation group of degree 30
+
+julia> abelian_invariants(G)
+ZZRingElem[]
+
+julia> quo(G, derived_subgroup(G)[1])
+(Permutation group of degree 1 and order 1, Hom: G -> permutation group)
+
+julia> subgroups(G)
+Base.Iterators.Flatten{Vector{GAPGroupConjClass{PermGroup, PermGroup}}}(GAPGroupConjClass{PermGroup, PermGroup}[Conjugacy class of permutation group in G, Conjugacy class of permutation group in G, Conjugacy class of permutation group in G, Conjugacy class of permutation group in G, Conjugacy class of permutation group in G, Conjugacy class of permutation group in G, Conjugacy class of permutation group in G, Conjugacy class of permutation group in G, Conjugacy class of permutation group in G])
+
+julia> center(G)
+(Permutation group of degree 5 and order 1, Hom: permutation group -> G)
+
+julia> derived_subgroup(G)
+(Alternating group of degree 5, Hom: Alt(5) -> G)
+
+julia> frattini_subgroup(G)
+(Permutation group of degree 5 and order 1, Hom: permutation group -> G)
+
+julia> fitting_subgroup(G)
+(Permutation group of degree 5, Hom: permutation group -> G)
+
+julia> solvable_radical(G)
+(Permutation group of degree 5 and order 1, Hom: permutation group -> G)
+
+julia> socle(G)
+(Alternating group of degree 5, Hom: Alt(5) -> G)
+
+julia> derived_series(G)
+1-element Vector{PermGroup}:
+ Alternating group of degree 5
+
+julia> chief_series(G)
+2-element Vector{PermGroup}:
+ Alternating group of degree 5
+ Permutation group of degree 5 and order 1
+
+julia> lower_central_series(G)
+1-element Vector{PermGroup}:
+ Alternating group of degree 5
+
+julia> upper_central_series(G)
+1-element Vector{PermGroup}:
+ Permutation group of degree 5 and order 1
+
+julia> character_table(G)  # Output not guaranteed to exactly match the LMFDB table
+Character table of alternating group of degree 5
+
+  2  2  2  .                 .                 .
+  3  1  .  1                 .                 .
+  5  1  .  .                 1                 1
+                                                
+    1a 2a 3a                5a                5b
+ 2P 1a 1a 3a                5b                5a
+ 3P 1a 2a 1a                5b                5a
+ 5P 1a 2a 3a                1a                1a
+                                                
+X_1  1  1  1                 1                 1
+X_2  4  .  1                -1                -1
+X_3  5  1 -1                 .                 .
+X_4  3 -1  . z_5^3 + z_5^2 + 1    -z_5^3 - z_5^2
+X_5  3 -1  .    -z_5^3 - z_5^2 z_5^3 + z_5^2 + 1
+
+julia> 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-A5-sage.log b/lmfdb/tests/snippet_tests/groups/abstract/code-A5-sage.log
new file mode 100644
index 0000000000..0b191edeff
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-A5-sage.log
@@ -0,0 +1,193 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+sage: G = AlternatingGroup(5)
+sage: G.order()
+60
+sage: G.exponent()
+30
+sage: libgap(G).AutomorphismGroup()
+<group of size 120 with 3 generators>
+sage: G.composition_series()
+[Subgroup generated by [(3,4,5), (1,2,3,4,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [()] of (Alternating group of order 5!/2 as a permutation group)]
+sage: libgap(G).NilpotencyClassOfGroup() if G.is_nilpotent() else -1
+-1
+sage: libgap(G).DerivedLength()
+0
+sage: G.is_abelian()
+False
+sage: G.is_cyclic()
+False
+sage: G.is_elementary_abelian()
+False
+sage: G.is_nilpotent()
+False
+sage: G.is_perfect()
+True
+sage: G.is_pgroup()
+False
+sage: G.is_polycyclic()
+False
+sage: G.is_simple()
+True
+sage: G.is_solvable()
+False
+sage: G.is_supersolvable()
+False
+sage: element_orders = [g.order() for g in G]
+sage: orders = sorted(list(set(element_orders)))
+sage: print("Orders:", orders)
+Orders: [1, 2, 3, 5]
+sage: print("Elements:", [element_orders.count(n) for n in orders], G.order())
+Elements: [1, 15, 20, 24] 60
+sage: cc_orders = [cc[0].order() for cc in G.conjugacy_classes()]
+sage: print("Conjugacy classes:", [cc_orders.count(n) for n in orders], len(cc_orders))
+Conjugacy classes: [1, 1, 1, 2] 5
+sage: G.conjugacy_classes()  # Output not guaranteed to exactly match the LMFDB table
+[Conjugacy class of () in Alternating group of order 5!/2 as a permutation group,
+ Conjugacy class of (1,2)(3,4) in Alternating group of order 5!/2 as a permutation group,
+ Conjugacy class of (1,2,3) in Alternating group of order 5!/2 as a permutation group,
+ Conjugacy class of (1,2,3,4,5) in Alternating group of order 5!/2 as a permutation group,
+ Conjugacy class of (1,2,3,5,4) in Alternating group of order 5!/2 as a permutation group]
+sage: character_degrees = [c[0] for c in G.character_table()]
+sage: [[n, character_degrees.count(n)] for n in set(character_degrees)]
+[[1, 1], [3, 2], [4, 1], [5, 1]]
+sage: SL(2,4)
+Special Linear Group of degree 2 over Finite Field in a of size 2^2
+sage: PSL(2,4)
+Permutation Group with generators [(3,4,5), (1,2,3)]
+sage: PSL(2,5)
+Permutation Group with generators [(3,5)(4,6), (1,2,5)(3,4,6)]
+sage: PGL(2,4)
+Permutation Group with generators [(3,5,4), (1,2,3)]
+sage: SO(3,4)
+Special Orthogonal Group of degree 3 over Finite Field in a of size 2^2
+sage: SU(2,4)
+Special Unitary Group of degree 2 over Finite Field in a of size 2^4
+sage: PSU(2,4)
+The projective special unitary group of degree 2 over Finite Field in a of size 2^2
+sage: PSU(2,5)
+The projective special unitary group of degree 2 over Finite Field of size 5
+sage: GO(3,4)
+General Orthogonal Group of degree 3 over Finite Field in a of size 2^2
+sage: PGU(2,4)
+The projective general unitary group of degree 2 over Finite Field in a of size 2^2
+sage: PermutationGroup(['(1,2,3,4,5)', '(1,2,3)'])
+Permutation Group with generators [(1,2,3), (1,2,3,4,5)]
+sage: MS = MatrixSpace(Integers(), 4, 4)
+sage: MatrixGroup([MS([[1, 1, 1, 0], [0, -1, -1, 0], [0, 1, 0, 0], [0, 0, 1, 1]]), MS([[0, 0, 0, 1], [0, -1, -1, -1], [0, 1, 0, 0], [-1, -1, 0, 0]])])
+Matrix group over Integer Ring with 2 generators (
+[ 1  1  1  0]  [ 0  0  0  1]
+[ 0 -1 -1  0]  [ 0 -1 -1 -1]
+[ 0  1  0  0]  [ 0  1  0  0]
+[ 0  0  1  1], [-1 -1  0  0]
+)
+sage: MS = MatrixSpace(GF(5), 3, 3)
+sage: MatrixGroup([MS([[2, 1, 1], [4, 0, 1], [1, 1, 3]]), MS([[1, 1, 4], [2, 0, 4], [2, 1, 3]])])
+Matrix group over Finite Field of size 5 with 2 generators (
+[2 1 1]  [1 1 4]
+[4 0 1]  [2 0 4]
+[1 1 3], [2 1 3]
+)
+sage: TransitiveGroup(5, 4)
+Transitive group number 4 of degree 5
+sage: TransitiveGroup(6, 12)
+Transitive group number 12 of degree 6
+sage: TransitiveGroup(10, 7)
+Transitive group number 7 of degree 10
+sage: TransitiveGroup(12, 33)
+Transitive group number 33 of degree 12
+sage: TransitiveGroup(15, 5)
+Transitive group number 5 of degree 15
+sage: TransitiveGroup(20, 15)
+Transitive group number 15 of degree 20
+sage: TransitiveGroup(30, 9)
+Transitive group number 9 of degree 30
+sage: G.quotient(G.commutator())
+Permutation Group with generators [()]
+sage: G.homology(2)
+Multiplicative Abelian group isomorphic to C2
+sage: G.subgroups()
+[Subgroup generated by [()] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,3)(4,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,4)(3,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,5)(3,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2)(4,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2)(3,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2)(3,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,3)(4,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,3)(2,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,3)(2,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,4)(3,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,4)(2,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,4)(2,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,5)(3,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,5)(2,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,5)(2,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(3,4,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,3,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,5,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,4,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,4,2)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,3,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,5,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,4,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,3)(4,5), (2,4)(3,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2)(4,5), (1,4)(2,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2)(3,4), (1,3)(2,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,3)(2,5), (1,5)(2,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,4)(3,5), (1,5)(3,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2,3,4,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,5,2,4,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2,4,5,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,4,5,2,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,4,2,3,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2,5,3,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(3,4,5), (1,2)(4,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,3)(4,5), (1,2,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,4,5), (1,5)(2,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,3,4), (1,5)(3,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,5,3), (1,4)(3,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,4,5), (1,3)(2,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,4)(3,5), (1,4,2)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,3)(2,4), (1,5,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2)(3,4), (1,2,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,3,4), (1,4)(2,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,4)(3,5), (1,5)(2,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2)(3,5), (1,4)(2,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,3)(2,5), (1,5)(3,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2)(3,4), (1,5)(2,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2)(4,5), (1,3)(2,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,3)(4,5), (1,4)(2,3)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(3,4,5), (2,4)(3,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,4,5), (1,4)(3,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,3,4), (1,3)(2,4)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2,3), (1,3)(2,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(1,2,5), (1,4)(2,5)] of (Alternating group of order 5!/2 as a permutation group),
+ Subgroup generated by [(2,4)(3,5), (1,2,5)] of (Alternating group of order 5!/2 as a permutation group)]
+sage: G.center()
+Subgroup generated by [()] of (Alternating group of order 5!/2 as a permutation group)
+sage: G.commutator()
+Permutation Group with generators [(3,4,5), (1,2,3,4,5)]
+sage: G.frattini_subgroup()
+Subgroup generated by [()] of (Alternating group of order 5!/2 as a permutation group)
+sage: G.fitting_subgroup()
+Subgroup generated by [()] of (Alternating group of order 5!/2 as a permutation group)
+sage: G.socle()
+Subgroup generated by [(3,4,5), (1,2,3,4,5)] of (Alternating group of order 5!/2 as a permutation group)
+sage: G.derived_series()
+[Subgroup generated by [(3,4,5), (1,2,3,4,5)] of (Alternating group of order 5!/2 as a permutation group)]
+sage: libgap(G).ChiefSeries()
+[ Alt( [ 1 .. 5 ] ), Group(()) ]
+sage: G.lower_central_series()
+[Subgroup generated by [(3,4,5), (1,2,3,4,5)] of (Alternating group of order 5!/2 as a permutation group)]
+sage: G.upper_central_series()
+[Subgroup generated by [()] of (Alternating group of order 5!/2 as a permutation group)]
+sage: G.character_table()  # Output not guaranteed to exactly match the LMFDB table
+[                    1                     1                     1                     1                     1]
+[                    3                    -1                     0 zeta5^3 + zeta5^2 + 1    -zeta5^3 - zeta5^2]
+[                    3                    -1                     0    -zeta5^3 - zeta5^2 zeta5^3 + zeta5^2 + 1]
+[                    4                     0                     1                    -1                    -1]
+[                    5                     1                    -1                     0                     0]
+sage: 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-A5-sage_gap.log b/lmfdb/tests/snippet_tests/groups/abstract/code-A5-sage_gap.log
new file mode 100644
index 0000000000..c0b9c80594
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-A5-sage_gap.log
@@ -0,0 +1,108 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+sage: G = libgap.eval('AlternatingGroup(5)')
+sage: G.Order()
+60
+sage: G.Exponent()
+30
+sage: G.AutomorphismGroup()
+<group of size 120 with 3 generators>
+sage: G.CompositionSeries()
+[ Alt( [ 1 .. 5 ] ), Group(()) ]
+sage: G.NilpotencyClassOfGroup() if G.IsNilpotentGroup() else -1
+-1
+sage: G.DerivedLength()
+0
+sage: G.IsAbelian()
+false
+sage: G.IsCyclic()
+false
+sage: G.IsElementaryAbelian()
+false
+sage: G.IsMonomialGroup()
+false
+sage: G.IsNilpotentGroup()
+false
+sage: G.IsPerfect()
+true
+sage: G.IsPGroup()
+false
+sage: G.IsPolycyclicGroup()
+false
+sage: G.IsSimpleGroup()
+true
+sage: G.IsSolvableGroup()
+false
+sage: G.IsSupersolvableGroup()
+false
+sage: element_orders = [g.Order() for g in G.Elements()]
+sage: orders = sorted(list(set(element_orders)))
+sage: print("Orders:", orders)
+Orders: [1, 2, 3, 5]
+sage: print("Elements:", [element_orders.count(n) for n in orders], G.Order())
+Elements: [1, 15, 20, 24] 60
+sage: cc_orders = [cc.Representative().Order() for cc in G.ConjugacyClasses()]
+sage: print("Conjugacy classes:", [cc_orders.count(n) for n in orders], len(cc_orders))
+Conjugacy classes: [1, 1, 1, 2] 5
+sage: G.ConjugacyClasses()  # Output not guaranteed to exactly match the LMFDB table
+[ ()^G, (1,2)(3,4)^G, (1,2,3)^G, (1,2,3,4,5)^G, (1,2,3,5,4)^G ]
+sage: G.CharacterDegrees()
+[ [ 1, 1 ], [ 3, 2 ], [ 4, 1 ], [ 5, 1 ] ]
+sage: gap.new('Group( (1,2,3,4,5), (1,2,3) )')
+Group( [ (1,2,3,4,5), (1,2,3) ] )
+sage: gap.new('Group([[[1, 1, 1, 0], [0, -1, -1, 0], [0, 1, 0, 0], [0, 0, 1, 1]], [[0, 0, 0, 1], [0, -1, -1, -1], [0, 1, 0, 0], [-1, -1, 0, 0]]])')
+Group([ [ [ 1, 1, 1, 0 ], [ 0, -1, -1, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 1 ] ], 
+  [ [ 0, 0, 0, 1 ], [ 0, -1, -1, -1 ], [ 0, 1, 0, 0 ], [ -1, -1, 0, 0 ] ] ])
+sage: gap.new('Group([[[ Z(5), Z(5)^0, Z(5)^0 ], [ Z(5)^2, 0*Z(5), Z(5)^0 ], [ Z(5)^0, Z(5)^0, Z(5)^3 ]], [[ Z(5)^0, Z(5)^0, Z(5)^2 ], [ Z(5), 0*Z(5), Z(5)^2 ], [ Z(5), Z(5)^0, Z(5)^3 ]]])')
+Group(
+[ 
+  [ [ Z(5), Z(5)^0, Z(5)^0 ], [ Z(5)^2, 0*Z(5), Z(5)^0 ], 
+      [ Z(5)^0, Z(5)^0, Z(5)^3 ] ], 
+  [ [ Z(5)^0, Z(5)^0, Z(5)^2 ], [ Z(5), 0*Z(5), Z(5)^2 ], 
+      [ Z(5), Z(5)^0, Z(5)^3 ] ] ])
+sage: libgap.TransitiveGroup(5, 4)
+A5
+sage: libgap.TransitiveGroup(6, 12)
+L(6) = PSL(2,5) = A_5(6)
+sage: libgap.TransitiveGroup(10, 7)
+A_5(10)
+sage: libgap.TransitiveGroup(12, 33)
+A_5(12)
+sage: libgap.TransitiveGroup(15, 5)
+A_5(15)
+sage: libgap.TransitiveGroup(20, 15)
+t20n15
+sage: libgap.TransitiveGroup(30, 9)
+t30n9
+sage: G.AbelianInvariants()
+[  ]
+sage: G.FactorGroup(G.DerivedSubgroup())
+Group(())
+sage: G.AbelianInvariantsMultiplier()
+[ 2 ]
+sage: G.CommutatorLength()
+1
+sage: G.AllSubgroups()
+[ Group(()), Group([ (2,3)(4,5) ]), Group([ (2,4)(3,5) ]), Group([ (2,5)(3,4) ]), Group([ (1,2)(4,5) ]), Group([ (1,2)(3,4) ]), Group([ (1,2)(3,5) ]), Group([ (1,3)(4,5) ]), Group([ (1,3)(2,4) ]), Group([ (1,3)(2,5) ]), Group([ (1,4)(3,5) ]), Group([ (1,4)(2,3) ]), Group([ (1,4)(2,5) ]), Group([ (1,5)(3,4) ]), Group([ (1,5)(2,3) ]), Group([ (1,5)(2,4) ]), Group([ (3,4,5) ]), Group([ (2,3,4) ]), Group([ (2,5,3) ]), Group([ (2,4,5) ]), Group([ (1,2,3) ]), Group([ (1,4,2) ]), Group([ (1,2,5) ]), Group([ (1,3,4) ]), Group([ (1,5,3) ]), Group([ (1,4,5) ]), Group([ (2,3)(4,5), (2,4)(3,5) ]), Group([ (1,2)(4,5), (1,4)(2,5) ]), Group([ (1,2)(3,4), (1,3)(2,4) ]), Group([ (1,5)(2,3), (1,3)(2,5) ]), Group([ (1,5)(3,4), (1,4)(3,5) ]), Group([ (1,2,3,4,5) ]), Group([ (1,5,2,4,3) ]), Group([ (1,2,4,5,3) ]), Group([ (1,4,5,2,3) ]), Group([ (1,4,2,3,5) ]), Group([ (1,2,5,3,4) ]), Group([ (1,2)(4,5), (3,4,5) ]), Group([ (2,3)(4,5), (1,2,3) ]), Group([ (1,5)(2,3), (1,4,5) ]), Group([ (1,5)(3,4), (2,3,4) ]), Group([ (1,4)(3,5), (2,5,3) ]), Group([ (1,3)(2,5), (2,4,5) ]), Group([ (2,4)(3,5), (1,4,2) ]), Group([ (1,3)(2,4), (1,5,3) ]), Group([ (1,2)(3,4), (1,2,5) ]), Group([ (1,4)(2,5), (1,3,4) ]), Group([ (1,5)(2,4), (1,4)(3,5) ]), Group([ (1,2)(3,5), (1,4)(2,5) ]), Group([ (1,3)(2,5), (1,5)(3,4) ]), Group([ (1,2)(3,4), (1,5)(2,3) ]), Group([ (1,3)(2,4), (1,2)(4,5) ]), Group([ (1,4)(2,3), (1,3)(4,5) ]), Group([ (3,4,5), (2,4)(3,5) ]), Group([ (1,4,5), (1,4)(3,5) ]), Group([ (2,3,4), (1,3)(2,4) ]), Group([ (1,2,3), (1,3)(2,5) ]), Group([ (1,2,5), (1,4)(2,5) ]), Group([ (2,4)(3,5), (1,2,5) ]) ]
+sage: G.Center()
+Group(())
+sage: G.DerivedSubgroup()
+Alt( [ 1 .. 5 ] )
+sage: G.FrattiniSubgroup()
+Group(())
+sage: G.FittingSubgroup()
+Group(())
+sage: G.SolvableRadical()
+Group(())
+sage: G.Socle()
+Alt( [ 1 .. 5 ] )
+sage: G.DerivedSeriesOfGroup()
+[ Alt( [ 1 .. 5 ] ) ]
+sage: G.ChiefSeries()
+[ Alt( [ 1 .. 5 ] ), Group(()) ]
+sage: G.LowerCentralSeriesOfGroup()
+[ Alt( [ 1 .. 5 ] ) ]
+sage: G.UpperCentralSeriesOfGroup()
+[ Group(()) ]
+sage: G.CharacterTable()  # Output not guaranteed to exactly match the LMFDB table
+CharacterTable( Alt( [ 1 .. 5 ] ) )
+sage: 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-C1-gap.log b/lmfdb/tests/snippet_tests/groups/abstract/code-C1-gap.log
new file mode 100644
index 0000000000..ebfff257a8
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-C1-gap.log
@@ -0,0 +1,95 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+gap> G := CyclicGroup(1);
+<pc group of size 1 with 0 generators>
+gap> Order(G);
+1
+gap> Exponent(G);
+1
+gap> AutomorphismGroup(G);
+<trivial group>
+gap> FactorGroup(AutomorphismGroup(G), InnerAutomorphismGroup(G));
+<trivial group>
+gap> CompositionSeries(G);
+[ Group([  ]) ]
+gap> if IsNilpotentGroup(G) then NilpotencyClassOfGroup(G); fi;
+gap> DerivedLength(G);
+0
+gap> IsAbelian(G);
+true
+gap> IsCyclic(G);
+true
+gap> IsElementaryAbelian(G);
+true
+gap> IsMonomialGroup(G);
+true
+gap> IsNilpotentGroup(G);
+true
+gap> IsPerfectGroup(G);
+true
+gap> IsPGroup(G);
+true
+gap> IsPolycyclicGroup(G);
+true
+gap> IsSimpleGroup(G);
+false
+gap> IsSolvableGroup(G);
+true
+gap> IsSupersolvableGroup(G);
+true
+gap> element_orders := List(Elements(G), g -> Order(g));
+[ 1 ]
+gap> orders := Set(element_orders);
+[ 1 ]
+gap> Print("Orders: ", orders, "\n");
+Orders: [ 1 ]
+gap> element_counts := List(orders, n -> Length(Filtered(element_orders, x -> x = n)));
+[ 1 ]
+gap> Print("Elements: ", element_counts, " ", Size(G), "\n");
+Elements: [ 1 ] 1
+gap> cc_orders := List(ConjugacyClasses(G), cc -> Order(Representative(cc)));
+[ 1 ]
+gap> cc_counts := List(orders, n -> Length(Filtered(cc_orders, x -> x = n)));
+[ 1 ]
+gap> Print("Conjugacy classes: ", cc_counts, " ", Length(ConjugacyClasses(G)), "\n");
+Conjugacy classes: [ 1 ] 1
+gap> ConjugacyClasses(G);  # Output not guaranteed to exactly match the LMFDB table
+[ <identity> of ...^G ]
+gap> CharacterDegrees(G);
+[ [ 1, 1 ] ]
+gap> GPC := PcGroupCode(0,1); 
+Group([  ])
+gap> TransitiveGroup(1, 1);
+fail
+gap> AbelianInvariants(G);
+[  ]
+gap> FactorGroup(G, DerivedSubgroup(G));
+<pc group of size 1 with 0 generators>
+gap> AbelianInvariantsMultiplier(G);
+[  ]
+gap> CommutatorLength(G);
+1
+gap> AllSubgroups(G);
+[ <pc group of size 1 with 0 generators> ]
+gap> Center(G);
+<pc group of size 1 with 0 generators>
+gap> DerivedSubgroup(G);
+Group([  ])
+gap> FrattiniSubgroup(G);
+<pc group of size 1 with 0 generators>
+gap> FittingSubgroup(G);
+<pc group of size 1 with 0 generators>
+gap> SolvableRadical(G);
+<pc group of size 1 with 0 generators>
+gap> Socle(G);
+<pc group of size 1 with 0 generators>
+gap> DerivedSeriesOfGroup(G);
+[ <pc group of size 1 with 0 generators> ]
+gap> ChiefSeries(G);
+[ Group([  ]) ]
+gap> LowerCentralSeriesOfGroup(G);
+[ <pc group of size 1 with 0 generators> ]
+gap> UpperCentralSeriesOfGroup(G);
+[ Group([  ]) ]
+gap> CharacterTable(G);  # Output not guaranteed to exactly match the LMFDB table
+CharacterTable( <pc group of size 1 with 0 generators> )
+gap> 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-C1-oscar.log b/lmfdb/tests/snippet_tests/groups/abstract/code-C1-oscar.log
new file mode 100644
index 0000000000..11f948babb
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-C1-oscar.log
@@ -0,0 +1,145 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+
+julia> G = cyclic_group(1)
+Pc group of order 1
+
+julia> order(G)
+1
+
+julia> exponent(G)
+1
+
+julia> automorphism_group(G)
+Automorphism group of
+  pc group of order 1
+
+julia> composition_series(G)
+1-element Vector{SubPcGroup}:
+ Sub-pc group of order 1
+
+julia> if is_nilpotent(G) nilpotency_class(G) end
+0
+
+julia> derived_length(G)
+0
+
+julia> is_abelian(G)
+true
+
+julia> is_cyclic(G)
+true
+
+julia> is_elementary_abelian(G)
+true
+
+julia> is_nilpotent(G)
+true
+
+julia> is_perfect(G)
+true
+
+julia> is_pgroup(G)
+true
+
+julia> is_simple(G)
+false
+
+julia> is_solvable(G)
+true
+
+julia> is_supersolvable(G)
+true
+
+julia> element_orders = [order(g) for g in elements(G)]
+1-element Vector{ZZRingElem}:
+ 1
+
+julia> orders = sort(unique(element_orders))
+1-element Vector{ZZRingElem}:
+ 1
+
+julia> println("Orders: ", orders)
+Orders: ZZRingElem[1]
+
+julia> element_counts = [count(==(n), element_orders) for n in orders]
+1-element Vector{Int64}:
+ 1
+
+julia> println("Elements: ", element_counts, " ", order(G))
+Elements: [1] 1
+
+julia> ccs = conjugacy_classes(G)
+1-element Vector{GAPGroupConjClass{PcGroup, PcGroupElem}}:
+ Conjugacy class of <identity> of ... in G
+
+julia> cc_orders = [order(representative(cc)) for cc in ccs]
+1-element Vector{ZZRingElem}:
+ 1
+
+julia> cc_counts = [count(==(n), cc_orders) for n in orders]
+1-element Vector{Int64}:
+ 1
+
+julia> println("Conjugacy classes: ", cc_counts, " ", length(ccs))
+Conjugacy classes: [1] 1
+
+julia> conjugacy_classes(G)  # Output not guaranteed to exactly match the LMFDB table
+1-element Vector{GAPGroupConjClass{PcGroup, PcGroupElem}}:
+ Conjugacy class of <identity> of ... in G
+
+julia> character_degrees(G)
+MSet{ZZRingElem} with 1 element:
+  1
+
+julia> abelian_invariants(G)
+ZZRingElem[]
+
+julia> quo(G, derived_subgroup(G)[1])
+(Pc group of order 1, Hom: G -> pc group)
+
+julia> subgroups(G)
+Base.Iterators.Flatten{Vector{GAPGroupConjClass{PcGroup, SubPcGroup}}}(GAPGroupConjClass{PcGroup, SubPcGroup}[Conjugacy class of sub-pc group in G])
+
+julia> center(G)
+(Sub-pc group of order 1, Hom: sub-pc group -> G)
+
+julia> derived_subgroup(G)
+(Sub-pc group of order 1, Hom: sub-pc group -> G)
+
+julia> frattini_subgroup(G)
+(Sub-pc group of order 1, Hom: sub-pc group -> G)
+
+julia> fitting_subgroup(G)
+(Sub-pc group of order 1, Hom: sub-pc group -> G)
+
+julia> solvable_radical(G)
+(Sub-pc group of order 1, Hom: sub-pc group -> G)
+
+julia> socle(G)
+(Sub-pc group of order 1, Hom: sub-pc group -> G)
+
+julia> derived_series(G)
+1-element Vector{SubPcGroup}:
+ Sub-pc group of order 1
+
+julia> chief_series(G)
+1-element Vector{SubPcGroup}:
+ Sub-pc group of order 1
+
+julia> lower_central_series(G)
+1-element Vector{SubPcGroup}:
+ Sub-pc group of order 1
+
+julia> upper_central_series(G)
+1-element Vector{SubPcGroup}:
+ Sub-pc group of order 1
+
+julia> character_table(G)  # Output not guaranteed to exactly match the LMFDB table
+Character table of pc group of order 1
+
+      
+    1a
+      
+X_1  1
+
+julia> 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-C1-sage.log b/lmfdb/tests/snippet_tests/groups/abstract/code-C1-sage.log
new file mode 100644
index 0000000000..3299d59bb3
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-C1-sage.log
@@ -0,0 +1,79 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+sage: G = CyclicPermutationGroup(1)
+sage: G.order()
+1
+sage: G.exponent()
+1
+sage: libgap(G).AutomorphismGroup()
+<trivial group>
+sage: G.composition_series()
+[Subgroup generated by [()] of (Cyclic group of order 1 as a permutation group)]
+sage: libgap(G).NilpotencyClassOfGroup() if G.is_nilpotent() else -1
+1
+sage: libgap(G).DerivedLength()
+0
+sage: G.is_abelian()
+True
+sage: G.is_cyclic()
+True
+sage: G.is_elementary_abelian()
+True
+sage: G.is_nilpotent()
+True
+sage: G.is_perfect()
+True
+sage: G.is_pgroup()
+True
+sage: G.is_polycyclic()
+True
+sage: G.is_simple()
+False
+sage: G.is_solvable()
+True
+sage: G.is_supersolvable()
+True
+sage: element_orders = [g.order() for g in G]
+sage: orders = sorted(list(set(element_orders)))
+sage: print("Orders:", orders)
+Orders: [1]
+sage: print("Elements:", [element_orders.count(n) for n in orders], G.order())
+Elements: [1] 1
+sage: cc_orders = [cc[0].order() for cc in G.conjugacy_classes()]
+sage: print("Conjugacy classes:", [cc_orders.count(n) for n in orders], len(cc_orders))
+Conjugacy classes: [1] 1
+sage: G.conjugacy_classes()  # Output not guaranteed to exactly match the LMFDB table
+[Conjugacy class of () in Cyclic group of order 1 as a permutation group]
+sage: character_degrees = [c[0] for c in G.character_table()]
+sage: [[n, character_degrees.count(n)] for n in set(character_degrees)]
+[[1, 1]]
+sage: GPC = gap.new('PcGroupCode(0,1)'); 
+sage: TransitiveGroup(1, 1)
+Transitive group number 1 of degree 1
+sage: G.quotient(G.commutator())
+Permutation Group with generators [()]
+sage: G.homology(2)
+Trivial Abelian group
+sage: G.subgroups()
+[Subgroup generated by [()] of (Cyclic group of order 1 as a permutation group)]
+sage: G.center()
+Subgroup generated by [()] of (Cyclic group of order 1 as a permutation group)
+sage: G.commutator()
+Permutation Group with generators [()]
+sage: G.frattini_subgroup()
+Subgroup generated by [()] of (Cyclic group of order 1 as a permutation group)
+sage: G.fitting_subgroup()
+Subgroup generated by [()] of (Cyclic group of order 1 as a permutation group)
+sage: G.socle()
+Subgroup generated by [()] of (Cyclic group of order 1 as a permutation group)
+sage: G.derived_series()
+[Subgroup generated by [()] of (Cyclic group of order 1 as a permutation group)]
+sage: libgap(G).ChiefSeries()
+[ Group(()) ]
+sage: G.lower_central_series()
+[Subgroup generated by [()] of (Cyclic group of order 1 as a permutation group),
+ Subgroup generated by [()] of (Cyclic group of order 1 as a permutation group)]
+sage: G.upper_central_series()
+[Subgroup generated by [()] of (Cyclic group of order 1 as a permutation group)]
+sage: G.character_table()  # Output not guaranteed to exactly match the LMFDB table
+[1]
+sage: 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-C1-sage_gap.log b/lmfdb/tests/snippet_tests/groups/abstract/code-C1-sage_gap.log
new file mode 100644
index 0000000000..759d76d462
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-C1-sage_gap.log
@@ -0,0 +1,85 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+sage: G = libgap.eval('CyclicGroup(1)')
+sage: G.Order()
+1
+sage: G.Exponent()
+1
+sage: G.AutomorphismGroup()
+<trivial group>
+sage: G.CompositionSeries()
+[ Group([  ]) ]
+sage: G.NilpotencyClassOfGroup() if G.IsNilpotentGroup() else -1
+0
+sage: G.DerivedLength()
+0
+sage: G.IsAbelian()
+true
+sage: G.IsCyclic()
+true
+sage: G.IsElementaryAbelian()
+true
+sage: G.IsMonomialGroup()
+true
+sage: G.IsNilpotentGroup()
+true
+sage: G.IsPerfect()
+true
+sage: G.IsPGroup()
+true
+sage: G.IsPolycyclicGroup()
+true
+sage: G.IsSimpleGroup()
+false
+sage: G.IsSolvableGroup()
+true
+sage: G.IsSupersolvableGroup()
+true
+sage: element_orders = [g.Order() for g in G.Elements()]
+sage: orders = sorted(list(set(element_orders)))
+sage: print("Orders:", orders)
+Orders: [1]
+sage: print("Elements:", [element_orders.count(n) for n in orders], G.Order())
+Elements: [1] 1
+sage: cc_orders = [cc.Representative().Order() for cc in G.ConjugacyClasses()]
+sage: print("Conjugacy classes:", [cc_orders.count(n) for n in orders], len(cc_orders))
+Conjugacy classes: [1] 1
+sage: G.ConjugacyClasses()  # Output not guaranteed to exactly match the LMFDB table
+[ <identity> of ...^G ]
+sage: G.CharacterDegrees()
+[ [ 1, 1 ] ]
+sage: GPC = gap.new('PcGroupCode(0,1)'); 
+sage: libgap.TransitiveGroup(1, 1)
+fail
+sage: G.AbelianInvariants()
+[  ]
+sage: G.FactorGroup(G.DerivedSubgroup())
+<pc group of size 1 with 0 generators>
+sage: G.AbelianInvariantsMultiplier()
+[  ]
+sage: G.CommutatorLength()
+1
+sage: G.AllSubgroups()
+[ <pc group of size 1 with 0 generators> ]
+sage: G.Center()
+<pc group of size 1 with 0 generators>
+sage: G.DerivedSubgroup()
+Group([  ])
+sage: G.FrattiniSubgroup()
+<pc group of size 1 with 0 generators>
+sage: G.FittingSubgroup()
+<pc group of size 1 with 0 generators>
+sage: G.SolvableRadical()
+<pc group of size 1 with 0 generators>
+sage: G.Socle()
+<pc group of size 1 with 0 generators>
+sage: G.DerivedSeriesOfGroup()
+[ <pc group of size 1 with 0 generators> ]
+sage: G.ChiefSeries()
+[ Group([  ]) ]
+sage: G.LowerCentralSeriesOfGroup()
+[ <pc group of size 1 with 0 generators> ]
+sage: G.UpperCentralSeriesOfGroup()
+[ Group([  ]) ]
+sage: G.CharacterTable()  # Output not guaranteed to exactly match the LMFDB table
+CharacterTable( <pc group of size 1 with 0 generators> )
+sage: 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-D4-gap.log b/lmfdb/tests/snippet_tests/groups/abstract/code-D4-gap.log
new file mode 100644
index 0000000000..ef513d0046
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-D4-gap.log
@@ -0,0 +1,107 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+gap> G := DihedralGroup(8);
+<pc group of size 8 with 3 generators>
+gap> Order(G);
+8
+gap> Exponent(G);
+4
+gap> AutomorphismGroup(G);
+<group of size 8 with 3 generators>
+gap> FactorGroup(AutomorphismGroup(G), InnerAutomorphismGroup(G));
+Group([ f1, <identity> of ..., <identity> of ... ])
+gap> CompositionSeries(G);
+[ Group([ f1, f2, f3 ]), Group([ f2, f3 ]), Group([ f3 ]), Group([  ]) ]
+gap> if IsNilpotentGroup(G) then NilpotencyClassOfGroup(G); fi;
+gap> DerivedLength(G);
+2
+gap> IsAbelian(G);
+false
+gap> IsCyclic(G);
+false
+gap> IsElementaryAbelian(G);
+false
+gap> IsMonomialGroup(G);
+true
+gap> IsNilpotentGroup(G);
+true
+gap> IsPerfectGroup(G);
+false
+gap> IsPGroup(G);
+true
+gap> IsPolycyclicGroup(G);
+true
+gap> IsSimpleGroup(G);
+false
+gap> IsSolvableGroup(G);
+true
+gap> IsSupersolvableGroup(G);
+true
+gap> element_orders := List(Elements(G), g -> Order(g));
+[ 1, 2, 4, 2, 2, 2, 4, 2 ]
+gap> orders := Set(element_orders);
+[ 1, 2, 4 ]
+gap> Print("Orders: ", orders, "\n");
+Orders: [ 1, 2, 4 ]
+gap> element_counts := List(orders, n -> Length(Filtered(element_orders, x -> x = n)));
+[ 1, 5, 2 ]
+gap> Print("Elements: ", element_counts, " ", Size(G), "\n");
+Elements: [ 1, 5, 2 ] 8
+gap> cc_orders := List(ConjugacyClasses(G), cc -> Order(Representative(cc)));
+[ 1, 2, 4, 2, 2 ]
+gap> cc_counts := List(orders, n -> Length(Filtered(cc_orders, x -> x = n)));
+[ 1, 3, 1 ]
+gap> Print("Conjugacy classes: ", cc_counts, " ", Length(ConjugacyClasses(G)), "\n");
+Conjugacy classes: [ 1, 3, 1 ] 5
+gap> ConjugacyClasses(G);  # Output not guaranteed to exactly match the LMFDB table
+[ <identity> of ...^G, f1^G, f2^G, f3^G, f1*f2^G ]
+gap> CharacterDegrees(G);
+[ [ 1, 4 ], [ 2, 1 ] ]
+gap> Group([[[ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ]], [[ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ]], [[ 0*Z(3), Z(3) ], [ Z(3), 0*Z(3) ]]]);
+Group([ [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ], [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ], [ [ 0*Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ] ])
+gap> GPC := PcGroupCode(294,8); a := GPC.1; b := GPC.2;
+<pc group of size 8 with 3 generators>
+f1
+f2
+gap> Group( (1,2), (1,3)(2,4), (1,2)(3,4) );
+Group([ (1,2), (1,3)(2,4), (1,2)(3,4) ])
+gap> Group([[[1, 0], [0, -1]], [[0, -1], [1, 0]]]);
+Group([ [ [ 1, 0 ], [ 0, -1 ] ], [ [ 0, -1 ], [ 1, 0 ] ] ])
+gap> Group([[[ 0*Z(3), Z(3)^0 ], [ Z(3)^0, 0*Z(3) ]], [[ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3) ]], [[ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ]]]);
+Group([ [ [ 0*Z(3), Z(3)^0 ], [ Z(3)^0, 0*Z(3) ] ], [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3) ] ], [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ])
+gap> TransitiveGroup(4, 3);
+D(4)
+gap> TransitiveGroup(8, 4);
+D_8(8)=[4]2
+gap> AbelianInvariants(G);
+[ 2, 2 ]
+gap> FactorGroup(G, DerivedSubgroup(G));
+Group([ f1, f2, <identity> of ... ])
+gap> AbelianInvariantsMultiplier(G);
+[ 2 ]
+gap> CommutatorLength(G);
+1
+gap> AllSubgroups(G);
+[ Group([  ]), Group([ f3 ]), Group([ f1 ]), Group([ f1*f3 ]), Group([ f1*f2 ]), Group([ f1*f2*f3 ]), Group([ f3, f1 ]), Group([ f3, f2 ]), Group([ f3, f1*f2 ]), Group([ f3, f1, f2 ]) ]
+gap> Center(G);
+Group([ f3 ])
+gap> DerivedSubgroup(G);
+Group([ f3 ])
+gap> FrattiniSubgroup(G);
+Group([ f3 ])
+gap> FittingSubgroup(G);
+<pc group of size 8 with 3 generators>
+gap> SolvableRadical(G);
+<pc group of size 8 with 3 generators>
+gap> Socle(G);
+Group([ f3 ])
+gap> DerivedSeriesOfGroup(G);
+[ <pc group of size 8 with 3 generators>, Group([ f3 ]), Group([  ]) ]
+gap> ChiefSeries(G);
+[ Group([ f1, f2, f3 ]), Group([ f2, f3 ]), Group([ f3 ]), Group([  ]) ]
+gap> LowerCentralSeriesOfGroup(G);
+[ <pc group of size 8 with 3 generators>, Group([ f3 ]), Group([ <identity> of ... ]) ]
+gap> UpperCentralSeriesOfGroup(G);
+[ Group([ f3, f1, f2 ]), Group([ f3 ]), Group([  ]) ]
+gap> CharacterTable(G);  # Output not guaranteed to exactly match the LMFDB table
+CharacterTable( <pc group of size 8 with 3 generators> )
+gap> 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-D4-oscar.log b/lmfdb/tests/snippet_tests/groups/abstract/code-D4-oscar.log
new file mode 100644
index 0000000000..f0b03c4eaf
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-D4-oscar.log
@@ -0,0 +1,213 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+
+julia> G = dihedral_group(8)
+Pc group of order 8
+
+julia> order(G)
+8
+
+julia> exponent(G)
+4
+
+julia> automorphism_group(G)
+Automorphism group of
+  pc group of order 8
+
+julia> composition_series(G)
+4-element Vector{SubPcGroup}:
+ Sub-pc group of order 8
+ Sub-pc group of order 4
+ Sub-pc group of order 2
+ Sub-pc group of order 1
+
+julia> if is_nilpotent(G) nilpotency_class(G) end
+2
+
+julia> derived_length(G)
+2
+
+julia> is_abelian(G)
+false
+
+julia> is_cyclic(G)
+false
+
+julia> is_elementary_abelian(G)
+false
+
+julia> is_nilpotent(G)
+true
+
+julia> is_perfect(G)
+false
+
+julia> is_pgroup(G)
+true
+
+julia> is_simple(G)
+false
+
+julia> is_solvable(G)
+true
+
+julia> is_supersolvable(G)
+true
+
+julia> element_orders = [order(g) for g in elements(G)]
+8-element Vector{ZZRingElem}:
+ 1
+ 2
+ 4
+ 2
+ 2
+ 2
+ 4
+ 2
+
+julia> orders = sort(unique(element_orders))
+3-element Vector{ZZRingElem}:
+ 1
+ 2
+ 4
+
+julia> println("Orders: ", orders)
+Orders: ZZRingElem[1, 2, 4]
+
+julia> element_counts = [count(==(n), element_orders) for n in orders]
+3-element Vector{Int64}:
+ 1
+ 5
+ 2
+
+julia> println("Elements: ", element_counts, " ", order(G))
+Elements: [1, 5, 2] 8
+
+julia> ccs = conjugacy_classes(G)
+5-element Vector{GAPGroupConjClass{PcGroup, PcGroupElem}}:
+ Conjugacy class of <identity> of ... in G
+ Conjugacy class of f1 in G
+ Conjugacy class of f2 in G
+ Conjugacy class of f3 in G
+ Conjugacy class of f1*f2 in G
+
+julia> cc_orders = [order(representative(cc)) for cc in ccs]
+5-element Vector{ZZRingElem}:
+ 1
+ 2
+ 4
+ 2
+ 2
+
+julia> cc_counts = [count(==(n), cc_orders) for n in orders]
+3-element Vector{Int64}:
+ 1
+ 3
+ 1
+
+julia> println("Conjugacy classes: ", cc_counts, " ", length(ccs))
+Conjugacy classes: [1, 3, 1] 5
+
+julia> conjugacy_classes(G)  # Output not guaranteed to exactly match the LMFDB table
+5-element Vector{GAPGroupConjClass{PcGroup, PcGroupElem}}:
+ Conjugacy class of <identity> of ... in G
+ Conjugacy class of f1 in G
+ Conjugacy class of f2 in G
+ Conjugacy class of f3 in G
+ Conjugacy class of f1*f2 in G
+
+julia> character_degrees(G)
+MSet{ZZRingElem} with 5 elements:
+  2
+  1 : 4
+
+julia> matrix_group([matrix(GF(3), [[2, 0], [0, 1]]), matrix(GF(3), [[2, 0], [0, 2]]), matrix(GF(3), [[0, 2], [2, 0]])])
+Matrix group of degree 2
+  over prime field of characteristic 3
+
+julia> @permutation_group(4, (1,2), (1,3)(2,4), (1,2)(3,4))
+Permutation group of degree 4
+
+julia> matrix_group([matrix(ZZ, [[1, 0], [0, -1]]), matrix(ZZ, [[0, -1], [1, 0]])])
+Matrix group of degree 2
+  over integer ring
+
+julia> matrix_group([matrix(GF(3), [[0, 1], [1, 0]]), matrix(GF(3), [[1, 0], [0, 2]]), matrix(GF(3), [[2, 0], [0, 2]])])
+Matrix group of degree 2
+  over prime field of characteristic 3
+
+julia> transitive_group(4, 3)
+Permutation group of degree 4
+
+julia> transitive_group(8, 4)
+Permutation group of degree 8
+
+julia> abelian_invariants(G)
+2-element Vector{ZZRingElem}:
+ 2
+ 2
+
+julia> quo(G, derived_subgroup(G)[1])
+(Pc group of order 4, Hom: G -> pc group)
+
+julia> subgroups(G)
+Base.Iterators.Flatten{Vector{GAPGroupConjClass{PcGroup, SubPcGroup}}}(GAPGroupConjClass{PcGroup, SubPcGroup}[Conjugacy class of sub-pc group in G, Conjugacy class of sub-pc group in G, Conjugacy class of sub-pc group in G, Conjugacy class of sub-pc group in G, Conjugacy class of sub-pc group in G, Conjugacy class of sub-pc group in G, Conjugacy class of sub-pc group in G, Conjugacy class of sub-pc group in G])
+
+julia> center(G)
+(Sub-pc group of order 2, Hom: sub-pc group -> G)
+
+julia> derived_subgroup(G)
+(Sub-pc group of order 2, Hom: sub-pc group -> G)
+
+julia> frattini_subgroup(G)
+(Sub-pc group of order 2, Hom: sub-pc group -> G)
+
+julia> fitting_subgroup(G)
+(Sub-pc group of order 8, Hom: sub-pc group -> G)
+
+julia> solvable_radical(G)
+(Sub-pc group of order 8, Hom: sub-pc group -> G)
+
+julia> socle(G)
+(Sub-pc group of order 2, Hom: sub-pc group -> G)
+
+julia> derived_series(G)
+3-element Vector{SubPcGroup}:
+ Sub-pc group of order 8
+ Sub-pc group of order 2
+ Sub-pc group of order 1
+
+julia> chief_series(G)
+4-element Vector{SubPcGroup}:
+ Sub-pc group of order 8
+ Sub-pc group of order 4
+ Sub-pc group of order 2
+ Sub-pc group of order 1
+
+julia> lower_central_series(G)
+3-element Vector{SubPcGroup}:
+ Sub-pc group of order 8
+ Sub-pc group of order 2
+ Sub-pc group of order 1
+
+julia> upper_central_series(G)
+3-element Vector{SubPcGroup}:
+ Sub-pc group of order 8
+ Sub-pc group of order 2
+ Sub-pc group of order 1
+
+julia> character_table(G)  # Output not guaranteed to exactly match the LMFDB table
+Character table of pc group of order 8
+
+  2  3  2  2  3  2
+                  
+    1a 2a 4a 2b 2c
+ 2P 1a 1a 2b 1a 1a
+ 3P 1a 2a 4a 2b 2c
+                  
+X_1  1  1  1  1  1
+X_2  1 -1  1  1 -1
+X_3  1  1 -1  1 -1
+X_4  1 -1 -1  1  1
+X_5  2  .  . -2  .
+
+julia> 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-D4-sage.log b/lmfdb/tests/snippet_tests/groups/abstract/code-D4-sage.log
new file mode 100644
index 0000000000..4b0a5fe3de
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-D4-sage.log
@@ -0,0 +1,126 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+sage: G = DihedralGroup(4)
+sage: G.order()
+8
+sage: G.exponent()
+4
+sage: libgap(G).AutomorphismGroup()
+<group of size 8 with 3 generators>
+sage: G.composition_series()
+[Subgroup generated by [(2,4), (1,2,3,4), (1,3)(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(1,2,3,4), (1,3)(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(1,3)(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [()] of (Dihedral group of order 8 as a permutation group)]
+sage: libgap(G).NilpotencyClassOfGroup() if G.is_nilpotent() else -1
+2
+sage: libgap(G).DerivedLength()
+2
+sage: G.is_abelian()
+False
+sage: G.is_cyclic()
+False
+sage: G.is_elementary_abelian()
+False
+sage: G.is_nilpotent()
+True
+sage: G.is_perfect()
+False
+sage: G.is_pgroup()
+True
+sage: G.is_polycyclic()
+True
+sage: G.is_simple()
+False
+sage: G.is_solvable()
+True
+sage: G.is_supersolvable()
+True
+sage: element_orders = [g.order() for g in G]
+sage: orders = sorted(list(set(element_orders)))
+sage: print("Orders:", orders)
+Orders: [1, 2, 4]
+sage: print("Elements:", [element_orders.count(n) for n in orders], G.order())
+Elements: [1, 5, 2] 8
+sage: cc_orders = [cc[0].order() for cc in G.conjugacy_classes()]
+sage: print("Conjugacy classes:", [cc_orders.count(n) for n in orders], len(cc_orders))
+Conjugacy classes: [1, 3, 1] 5
+sage: G.conjugacy_classes()  # Output not guaranteed to exactly match the LMFDB table
+[Conjugacy class of () in Dihedral group of order 8 as a permutation group,
+ Conjugacy class of (2,4) in Dihedral group of order 8 as a permutation group,
+ Conjugacy class of (1,2)(3,4) in Dihedral group of order 8 as a permutation group,
+ Conjugacy class of (1,2,3,4) in Dihedral group of order 8 as a permutation group,
+ Conjugacy class of (1,3)(2,4) in Dihedral group of order 8 as a permutation group]
+sage: character_degrees = [c[0] for c in G.character_table()]
+sage: [[n, character_degrees.count(n)] for n in set(character_degrees)]
+[[1, 4], [2, 1]]
+sage: MS = MatrixSpace(GF(3), 2, 2)
+sage: MatrixGroup([MS([[2, 0], [0, 1]]), MS([[2, 0], [0, 2]]), MS([[0, 2], [2, 0]])])
+Matrix group over Finite Field of size 3 with 3 generators (
+[2 0]  [2 0]  [0 2]
+[0 1], [0 2], [2 0]
+)
+sage: GPC = gap.new('PcGroupCode(294,8)'); a = GPC.1; b = GPC.2;
+sage: PermutationGroup(['(1,2)', '(1,3)(2,4)', '(1,2)(3,4)'])
+Permutation Group with generators [(1,2), (1,2)(3,4), (1,3)(2,4)]
+sage: MS = MatrixSpace(Integers(), 2, 2)
+sage: MatrixGroup([MS([[1, 0], [0, -1]]), MS([[0, -1], [1, 0]])])
+Matrix group over Integer Ring with 2 generators (
+[ 1  0]  [ 0 -1]
+[ 0 -1], [ 1  0]
+)
+sage: MS = MatrixSpace(GF(3), 2, 2)
+sage: MatrixGroup([MS([[0, 1], [1, 0]]), MS([[1, 0], [0, 2]]), MS([[2, 0], [0, 2]])])
+Matrix group over Finite Field of size 3 with 3 generators (
+[0 1]  [1 0]  [2 0]
+[1 0], [0 2], [0 2]
+)
+sage: TransitiveGroup(4, 3)
+Transitive group number 3 of degree 4
+sage: TransitiveGroup(8, 4)
+Transitive group number 4 of degree 8
+sage: G.quotient(G.commutator())
+Permutation Group with generators [(1,2)(3,4), (1,3)(2,4)]
+sage: G.homology(2)
+Multiplicative Abelian group isomorphic to C2
+sage: G.subgroups()
+[Subgroup generated by [()] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(1,3)(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(1,3)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(1,2)(3,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(1,4)(2,3)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(2,4), (1,3)(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(1,2,3,4), (1,3)(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(1,2)(3,4), (1,3)(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(2,4), (1,2,3,4), (1,3)(2,4)] of (Dihedral group of order 8 as a permutation group)]
+sage: G.center()
+Subgroup generated by [(1,3)(2,4)] of (Dihedral group of order 8 as a permutation group)
+sage: G.commutator()
+Permutation Group with generators [(1,3)(2,4)]
+sage: G.frattini_subgroup()
+Subgroup generated by [(1,3)(2,4)] of (Dihedral group of order 8 as a permutation group)
+sage: G.fitting_subgroup()
+Subgroup generated by [(1,2,3,4), (1,4)(2,3)] of (Dihedral group of order 8 as a permutation group)
+sage: G.socle()
+Subgroup generated by [(1,3)(2,4)] of (Dihedral group of order 8 as a permutation group)
+sage: G.derived_series()
+[Subgroup generated by [(1,2,3,4), (1,4)(2,3)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(1,3)(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [()] of (Dihedral group of order 8 as a permutation group)]
+sage: libgap(G).ChiefSeries()
+[ Group([ (2,4), (1,2,3,4), (1,3)(2,4) ]), Group([ (1,2,3,4), (1,3)(2,4) ]), Group([ (1,3)(2,4) ]), Group(()) ]
+sage: G.lower_central_series()
+[Subgroup generated by [(1,2,3,4), (1,4)(2,3)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(1,3)(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [()] of (Dihedral group of order 8 as a permutation group)]
+sage: G.upper_central_series()
+[Subgroup generated by [(2,4), (1,2,3,4), (1,3)(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [(1,3)(2,4)] of (Dihedral group of order 8 as a permutation group),
+ Subgroup generated by [()] of (Dihedral group of order 8 as a permutation group)]
+sage: G.character_table()  # Output not guaranteed to exactly match the LMFDB table
+[ 1  1  1  1  1]
+[ 1 -1 -1  1  1]
+[ 1  1 -1 -1  1]
+[ 1 -1  1 -1  1]
+[ 2  0  0  0 -2]
+sage: 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-D4-sage_gap.log b/lmfdb/tests/snippet_tests/groups/abstract/code-D4-sage_gap.log
new file mode 100644
index 0000000000..908bc223aa
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-D4-sage_gap.log
@@ -0,0 +1,95 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+sage: G = libgap.eval('DihedralGroup(8)')
+sage: G.Order()
+8
+sage: G.Exponent()
+4
+sage: G.AutomorphismGroup()
+<group of size 8 with 3 generators>
+sage: G.CompositionSeries()
+[ Group([ f1, f2, f3 ]), Group([ f2, f3 ]), Group([ f3 ]), Group([  ]) ]
+sage: G.NilpotencyClassOfGroup() if G.IsNilpotentGroup() else -1
+2
+sage: G.DerivedLength()
+2
+sage: G.IsAbelian()
+false
+sage: G.IsCyclic()
+false
+sage: G.IsElementaryAbelian()
+false
+sage: G.IsMonomialGroup()
+true
+sage: G.IsNilpotentGroup()
+true
+sage: G.IsPerfect()
+false
+sage: G.IsPGroup()
+true
+sage: G.IsPolycyclicGroup()
+true
+sage: G.IsSimpleGroup()
+false
+sage: G.IsSolvableGroup()
+true
+sage: G.IsSupersolvableGroup()
+true
+sage: element_orders = [g.Order() for g in G.Elements()]
+sage: orders = sorted(list(set(element_orders)))
+sage: print("Orders:", orders)
+Orders: [1, 2, 4]
+sage: print("Elements:", [element_orders.count(n) for n in orders], G.Order())
+Elements: [1, 5, 2] 8
+sage: cc_orders = [cc.Representative().Order() for cc in G.ConjugacyClasses()]
+sage: print("Conjugacy classes:", [cc_orders.count(n) for n in orders], len(cc_orders))
+Conjugacy classes: [1, 3, 1] 5
+sage: G.ConjugacyClasses()  # Output not guaranteed to exactly match the LMFDB table
+[ <identity> of ...^G, f1^G, f2^G, f3^G, f1*f2^G ]
+sage: G.CharacterDegrees()
+[ [ 1, 4 ], [ 2, 1 ] ]
+sage: GPC = gap.new('PcGroupCode(294,8)'); a = GPC.1; b = GPC.2;
+sage: gap.new('Group( (1,2), (1,3)(2,4), (1,2)(3,4) )')
+Group( [ (1,2), (1,3)(2,4), (1,2)(3,4) ] )
+sage: gap.new('Group([[[1, 0], [0, -1]], [[0, -1], [1, 0]]])')
+Group([ [ [ 1, 0 ], [ 0, -1 ] ], [ [ 0, -1 ], [ 1, 0 ] ] ])
+sage: gap.new('Group([[[ 0*Z(3), Z(3)^0 ], [ Z(3)^0, 0*Z(3) ]], [[ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3) ]], [[ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ]]])')
+Group([ [ [ 0*Z(3), Z(3)^0 ], [ Z(3)^0, 0*Z(3) ] ], 
+  [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3) ] ], 
+  [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ])
+sage: libgap.TransitiveGroup(4, 3)
+D(4)
+sage: libgap.TransitiveGroup(8, 4)
+D_8(8)=[4]2
+sage: G.AbelianInvariants()
+[ 2, 2 ]
+sage: G.FactorGroup(G.DerivedSubgroup())
+Group([ f1, f2, <identity> of ... ])
+sage: G.AbelianInvariantsMultiplier()
+[ 2 ]
+sage: G.CommutatorLength()
+1
+sage: G.AllSubgroups()
+[ Group([  ]), Group([ f3 ]), Group([ f1 ]), Group([ f1*f3 ]), Group([ f1*f2 ]), Group([ f1*f2*f3 ]), Group([ f3, f1 ]), Group([ f3, f2 ]), Group([ f3, f1*f2 ]), Group([ f3, f1, f2 ]) ]
+sage: G.Center()
+Group([ f3 ])
+sage: G.DerivedSubgroup()
+Group([ f3 ])
+sage: G.FrattiniSubgroup()
+Group([ f3 ])
+sage: G.FittingSubgroup()
+<pc group of size 8 with 3 generators>
+sage: G.SolvableRadical()
+<pc group of size 8 with 3 generators>
+sage: G.Socle()
+Group([ f3 ])
+sage: G.DerivedSeriesOfGroup()
+[ <pc group of size 8 with 3 generators>, Group([ f3 ]), Group([  ]) ]
+sage: G.ChiefSeries()
+[ Group([ f1, f2, f3 ]), Group([ f2, f3 ]), Group([ f3 ]), Group([  ]) ]
+sage: G.LowerCentralSeriesOfGroup()
+[ <pc group of size 8 with 3 generators>, Group([ f3 ]), Group([ <identity> of ... ]) ]
+sage: G.UpperCentralSeriesOfGroup()
+[ Group([ f3, f1, f2 ]), Group([ f3 ]), Group([  ]) ]
+sage: G.CharacterTable()  # Output not guaranteed to exactly match the LMFDB table
+CharacterTable( <pc group of size 8 with 3 generators> )
+sage: 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-S3-gap.log b/lmfdb/tests/snippet_tests/groups/abstract/code-S3-gap.log
new file mode 100644
index 0000000000..dc9ade0320
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-S3-gap.log
@@ -0,0 +1,135 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+gap> G := SymmetricGroup(3);
+Sym( [ 1 .. 3 ] )
+gap> Order(G);
+6
+gap> Exponent(G);
+6
+gap> AutomorphismGroup(G);
+<group of size 6 with 2 generators>
+gap> FactorGroup(AutomorphismGroup(G), InnerAutomorphismGroup(G));
+Group(())
+gap> CompositionSeries(G);
+[ Group([ (2,3), (1,2,3) ]), Group([ (1,2,3) ]), Group(()) ]
+gap> if IsNilpotentGroup(G) then NilpotencyClassOfGroup(G); fi;
+gap> DerivedLength(G);
+2
+gap> IsAbelian(G);
+false
+gap> IsCyclic(G);
+false
+gap> IsElementaryAbelian(G);
+false
+gap> IsMonomialGroup(G);
+true
+gap> IsNilpotentGroup(G);
+false
+gap> IsPerfectGroup(G);
+false
+gap> IsPGroup(G);
+false
+gap> IsPolycyclicGroup(G);
+true
+gap> IsSimpleGroup(G);
+false
+gap> IsSolvableGroup(G);
+true
+gap> IsSupersolvableGroup(G);
+true
+gap> element_orders := List(Elements(G), g -> Order(g));
+[ 1, 2, 2, 3, 3, 2 ]
+gap> orders := Set(element_orders);
+[ 1, 2, 3 ]
+gap> Print("Orders: ", orders, "\n");
+Orders: [ 1, 2, 3 ]
+gap> element_counts := List(orders, n -> Length(Filtered(element_orders, x -> x = n)));
+[ 1, 3, 2 ]
+gap> Print("Elements: ", element_counts, " ", Size(G), "\n");
+Elements: [ 1, 3, 2 ] 6
+gap> cc_orders := List(ConjugacyClasses(G), cc -> Order(Representative(cc)));
+[ 1, 2, 3 ]
+gap> cc_counts := List(orders, n -> Length(Filtered(cc_orders, x -> x = n)));
+[ 1, 1, 1 ]
+gap> Print("Conjugacy classes: ", cc_counts, " ", Length(ConjugacyClasses(G)), "\n");
+Conjugacy classes: [ 1, 1, 1 ] 3
+gap> ConjugacyClasses(G);  # Output not guaranteed to exactly match the LMFDB table
+[ ()^G, (1,2)^G, (1,2,3)^G ]
+gap> CharacterDegrees(G);
+[ [ 1, 2 ], [ 2, 1 ] ]
+gap> GL(2,2);
+SL(2,2)
+gap> SL(2,2);
+SL(2,2)
+gap> PSL(2,2);
+Group([ (2,3), (1,2) ])
+gap> PGL(2,2);
+Group([ (2,3), (1,2) ])
+gap> SO(3,2);
+GO(0,3,2)
+gap> SU(2,2);
+SU(2,2)
+gap> PSO(3,2);
+Group([ (2,7)(3,6), (1,2)(5,6) ])
+gap> PSU(2,2);
+Group([ (2,3)(4,5), (1,2)(4,5) ])
+gap> GO(3,2);
+GO(0,3,2)
+gap> Omega(3,2);
+GO(0,3,2)
+gap> PGO(3,2);
+Group([ (2,7)(3,6), (1,2)(5,6) ])
+gap> PGU(2,2);
+Group([ (2,3)(4,5), (1,2)(4,5) ])
+gap> POmega(3,2);
+Group([ (2,7)(3,6), (1,2)(5,6) ])
+gap> PGammaL(2,2);
+Group([ (2,3), (1,2) ])
+gap> PSigmaL(2,2);
+Group([ (2,3), (1,2) ])
+gap> GPC := PcGroupCode(25,6); a := GPC.1; b := GPC.2;
+<pc group of size 6 with 2 generators>
+f1
+f2
+gap> Group( (2,3), (1,3,2) );
+Group([ (2,3), (1,3,2) ])
+gap> Group([[[0, -1], [-1, 0]], [[-1, -1], [1, 0]]]);
+Group([ [ [ 0, -1 ], [ -1, 0 ] ], [ [ -1, -1 ], [ 1, 0 ] ] ])
+gap> Group([[[ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ]], [[ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ]]]);
+Group([ <an immutable 2x2 matrix over GF2>, <an immutable 2x2 matrix over GF2> ])
+gap> TransitiveGroup(3, 2);
+S3
+gap> TransitiveGroup(6, 2);
+D_6(6) = [3]2
+gap> AbelianInvariants(G);
+[ 2 ]
+gap> FactorGroup(G, DerivedSubgroup(G));
+<pc group with 1 generator>
+gap> AbelianInvariantsMultiplier(G);
+[  ]
+gap> CommutatorLength(G);
+1
+gap> AllSubgroups(G);
+[ Group(()), Group([ (2,3) ]), Group([ (1,2) ]), Group([ (1,3) ]), Group([ (1,2,3) ]), Group([ (1,2,3), (2,3) ]) ]
+gap> Center(G);
+Group(())
+gap> DerivedSubgroup(G);
+Alt( [ 1 .. 3 ] )
+gap> FrattiniSubgroup(G);
+Group(())
+gap> FittingSubgroup(G);
+Group([ (1,2,3) ])
+gap> SolvableRadical(G);
+Sym( [ 1 .. 3 ] )
+gap> Socle(G);
+Group([ (1,2,3) ])
+gap> DerivedSeriesOfGroup(G);
+[ Sym( [ 1 .. 3 ] ), Alt( [ 1 .. 3 ] ), Group(()) ]
+gap> ChiefSeries(G);
+[ Group([ (2,3), (1,2,3) ]), Group([ (1,2,3) ]), Group(()) ]
+gap> LowerCentralSeriesOfGroup(G);
+[ Sym( [ 1 .. 3 ] ), Alt( [ 1 .. 3 ] ) ]
+gap> UpperCentralSeriesOfGroup(G);
+[ Group(()) ]
+gap> CharacterTable(G);  # Output not guaranteed to exactly match the LMFDB table
+CharacterTable( Sym( [ 1 .. 3 ] ) )
+gap> 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-S3-oscar.log b/lmfdb/tests/snippet_tests/groups/abstract/code-S3-oscar.log
new file mode 100644
index 0000000000..80247e561f
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-S3-oscar.log
@@ -0,0 +1,208 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+
+julia> G = symmetric_group(3)
+Symmetric group of degree 3
+
+julia> order(G)
+6
+
+julia> exponent(G)
+6
+
+julia> automorphism_group(G)
+Automorphism group of
+  symmetric group of degree 3
+
+julia> composition_series(G)
+3-element Vector{PermGroup}:
+ Permutation group of degree 3 and order 6
+ Permutation group of degree 3 and order 3
+ Permutation group of degree 3 and order 1
+
+julia> if is_nilpotent(G) nilpotency_class(G) end
+
+julia> derived_length(G)
+2
+
+julia> is_abelian(G)
+false
+
+julia> is_cyclic(G)
+false
+
+julia> is_elementary_abelian(G)
+false
+
+julia> is_nilpotent(G)
+false
+
+julia> is_perfect(G)
+false
+
+julia> is_pgroup(G)
+false
+
+julia> is_simple(G)
+false
+
+julia> is_solvable(G)
+true
+
+julia> is_supersolvable(G)
+true
+
+julia> element_orders = [order(g) for g in elements(G)]
+6-element Vector{ZZRingElem}:
+ 1
+ 2
+ 2
+ 3
+ 3
+ 2
+
+julia> orders = sort(unique(element_orders))
+3-element Vector{ZZRingElem}:
+ 1
+ 2
+ 3
+
+julia> println("Orders: ", orders)
+Orders: ZZRingElem[1, 2, 3]
+
+julia> element_counts = [count(==(n), element_orders) for n in orders]
+3-element Vector{Int64}:
+ 1
+ 3
+ 2
+
+julia> println("Elements: ", element_counts, " ", order(G))
+Elements: [1, 3, 2] 6
+
+julia> ccs = conjugacy_classes(G)
+3-element Vector{GAPGroupConjClass{PermGroup, PermGroupElem}}:
+ Conjugacy class of () in G
+ Conjugacy class of (1,2) in G
+ Conjugacy class of (1,2,3) in G
+
+julia> cc_orders = [order(representative(cc)) for cc in ccs]
+3-element Vector{ZZRingElem}:
+ 1
+ 2
+ 3
+
+julia> cc_counts = [count(==(n), cc_orders) for n in orders]
+3-element Vector{Int64}:
+ 1
+ 1
+ 1
+
+julia> println("Conjugacy classes: ", cc_counts, " ", length(ccs))
+Conjugacy classes: [1, 1, 1] 3
+
+julia> conjugacy_classes(G)  # Output not guaranteed to exactly match the LMFDB table
+3-element Vector{GAPGroupConjClass{PermGroup, PermGroupElem}}:
+ Conjugacy class of () in G
+ Conjugacy class of (1,2) in G
+ Conjugacy class of (1,2,3) in G
+
+julia> character_degrees(G)
+MSet{ZZRingElem} with 3 elements:
+  2
+  1 : 2
+
+julia> GL(2,2)
+GL(2,2)
+
+julia> SL(2,2)
+SL(2,2)
+
+julia> SO(3,2)
+GO(3,2)
+
+julia> SU(2,2)
+SU(2,2)
+
+julia> GO(3,2)
+GO(3,2)
+
+julia> @permutation_group(3, (2,3), (1,3,2))
+Permutation group of degree 3
+
+julia> matrix_group([matrix(ZZ, [[0, -1], [-1, 0]]), matrix(ZZ, [[-1, -1], [1, 0]])])
+Matrix group of degree 2
+  over integer ring
+
+julia> matrix_group([matrix(GF(2), [[1, 1], [0, 1]]), matrix(GF(2), [[0, 1], [1, 0]])])
+Matrix group of degree 2
+  over prime field of characteristic 2
+
+julia> transitive_group(3, 2)
+Symmetric group of degree 3
+
+julia> transitive_group(6, 2)
+Permutation group of degree 6
+
+julia> abelian_invariants(G)
+1-element Vector{ZZRingElem}:
+ 2
+
+julia> quo(G, derived_subgroup(G)[1])
+(Pc group of order 2, Hom: G -> pc group)
+
+julia> subgroups(G)
+Base.Iterators.Flatten{Vector{GAPGroupConjClass{PermGroup, PermGroup}}}(GAPGroupConjClass{PermGroup, PermGroup}[Conjugacy class of permutation group in G, Conjugacy class of permutation group in G, Conjugacy class of permutation group in G, Conjugacy class of permutation group in G])
+
+julia> center(G)
+(Permutation group of degree 3 and order 1, Hom: permutation group -> G)
+
+julia> derived_subgroup(G)
+(Alternating group of degree 3, Hom: Alt(3) -> G)
+
+julia> frattini_subgroup(G)
+(Permutation group of degree 3 and order 1, Hom: permutation group -> G)
+
+julia> fitting_subgroup(G)
+(Permutation group of degree 3, Hom: permutation group -> G)
+
+julia> solvable_radical(G)
+(Symmetric group of degree 3, Hom: Sym(3) -> G)
+
+julia> socle(G)
+(Permutation group of degree 3 and order 3, Hom: permutation group -> G)
+
+julia> derived_series(G)
+3-element Vector{PermGroup}:
+ Symmetric group of degree 3
+ Alternating group of degree 3
+ Permutation group of degree 3 and order 1
+
+julia> chief_series(G)
+3-element Vector{PermGroup}:
+ Permutation group of degree 3 and order 6
+ Permutation group of degree 3 and order 3
+ Permutation group of degree 3 and order 1
+
+julia> lower_central_series(G)
+2-element Vector{PermGroup}:
+ Symmetric group of degree 3
+ Alternating group of degree 3
+
+julia> upper_central_series(G)
+1-element Vector{PermGroup}:
+ Permutation group of degree 3 and order 1
+
+julia> character_table(G)  # Output not guaranteed to exactly match the LMFDB table
+Character table of symmetric group of degree 3
+
+  2  1  1  .
+  3  1  .  1
+            
+    1a 2a 3a
+ 2P 1a 1a 3a
+ 3P 1a 2a 1a
+            
+X_1  1 -1  1
+X_2  2  . -1
+X_3  1  1  1
+
+julia> 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-S3-sage.log b/lmfdb/tests/snippet_tests/groups/abstract/code-S3-sage.log
new file mode 100644
index 0000000000..52fafab8cc
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-S3-sage.log
@@ -0,0 +1,126 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+sage: G = SymmetricGroup(3)
+sage: G.order()
+6
+sage: G.exponent()
+6
+sage: libgap(G).AutomorphismGroup()
+<group of size 6 with 2 generators>
+sage: G.composition_series()
+[Subgroup generated by [(2,3), (1,2,3)] of (Symmetric group of order 3! as a permutation group),
+ Subgroup generated by [(1,2,3)] of (Symmetric group of order 3! as a permutation group),
+ Subgroup generated by [()] of (Symmetric group of order 3! as a permutation group)]
+sage: libgap(G).NilpotencyClassOfGroup() if G.is_nilpotent() else -1
+-1
+sage: libgap(G).DerivedLength()
+2
+sage: G.is_abelian()
+False
+sage: G.is_cyclic()
+False
+sage: G.is_elementary_abelian()
+False
+sage: G.is_nilpotent()
+False
+sage: G.is_perfect()
+False
+sage: G.is_pgroup()
+False
+sage: G.is_polycyclic()
+True
+sage: G.is_simple()
+False
+sage: G.is_solvable()
+True
+sage: G.is_supersolvable()
+True
+sage: element_orders = [g.order() for g in G]
+sage: orders = sorted(list(set(element_orders)))
+sage: print("Orders:", orders)
+Orders: [1, 2, 3]
+sage: print("Elements:", [element_orders.count(n) for n in orders], G.order())
+Elements: [1, 3, 2] 6
+sage: cc_orders = [cc[0].order() for cc in G.conjugacy_classes()]
+sage: print("Conjugacy classes:", [cc_orders.count(n) for n in orders], len(cc_orders))
+Conjugacy classes: [1, 1, 1] 3
+sage: G.conjugacy_classes()  # Output not guaranteed to exactly match the LMFDB table
+[Conjugacy class of cycle type [1, 1, 1] in Symmetric group of order 3! as a permutation group,
+ Conjugacy class of cycle type [2, 1] in Symmetric group of order 3! as a permutation group,
+ Conjugacy class of cycle type [3] in Symmetric group of order 3! as a permutation group]
+sage: character_degrees = [c[0] for c in G.character_table()]
+sage: [[n, character_degrees.count(n)] for n in set(character_degrees)]
+[[1, 2], [2, 1]]
+sage: GL(2,2)
+General Linear Group of degree 2 over Finite Field of size 2
+sage: SL(2,2)
+Special Linear Group of degree 2 over Finite Field of size 2
+sage: PSL(2,2)
+Permutation Group with generators [(2,3), (1,2)]
+sage: PGL(2,2)
+Permutation Group with generators [(2,3), (1,2)]
+sage: SO(3,2)
+Special Orthogonal Group of degree 3 over Finite Field of size 2
+sage: SU(2,2)
+Special Unitary Group of degree 2 over Finite Field in a of size 2^2
+sage: PSU(2,2)
+The projective special unitary group of degree 2 over Finite Field of size 2
+sage: GO(3,2)
+General Orthogonal Group of degree 3 over Finite Field of size 2
+sage: PGU(2,2)
+The projective general unitary group of degree 2 over Finite Field of size 2
+sage: GPC = gap.new('PcGroupCode(25,6)'); a = GPC.1; b = GPC.2;
+sage: PermutationGroup(['(2,3)', '(1,3,2)'])
+Permutation Group with generators [(2,3), (1,3,2)]
+sage: MS = MatrixSpace(Integers(), 2, 2)
+sage: MatrixGroup([MS([[0, -1], [-1, 0]]), MS([[-1, -1], [1, 0]])])
+Matrix group over Integer Ring with 2 generators (
+[ 0 -1]  [-1 -1]
+[-1  0], [ 1  0]
+)
+sage: MS = MatrixSpace(GF(2), 2, 2)
+sage: MatrixGroup([MS([[1, 1], [0, 1]]), MS([[0, 1], [1, 0]])])
+Matrix group over Finite Field of size 2 with 2 generators (
+[1 1]  [0 1]
+[0 1], [1 0]
+)
+sage: TransitiveGroup(3, 2)
+Transitive group number 2 of degree 3
+sage: TransitiveGroup(6, 2)
+Transitive group number 2 of degree 6
+sage: G.quotient(G.commutator())
+Permutation Group with generators [(1,2)]
+sage: G.homology(2)
+Trivial Abelian group
+sage: G.subgroups()
+[Subgroup generated by [()] of (Symmetric group of order 3! as a permutation group),
+ Subgroup generated by [(2,3)] of (Symmetric group of order 3! as a permutation group),
+ Subgroup generated by [(1,2)] of (Symmetric group of order 3! as a permutation group),
+ Subgroup generated by [(1,3)] of (Symmetric group of order 3! as a permutation group),
+ Subgroup generated by [(1,2,3)] of (Symmetric group of order 3! as a permutation group),
+ Subgroup generated by [(2,3), (1,2,3)] of (Symmetric group of order 3! as a permutation group)]
+sage: G.center()
+Subgroup generated by [()] of (Symmetric group of order 3! as a permutation group)
+sage: G.commutator()
+Permutation Group with generators [(1,2,3)]
+sage: G.frattini_subgroup()
+Subgroup generated by [()] of (Symmetric group of order 3! as a permutation group)
+sage: G.fitting_subgroup()
+Subgroup generated by [(1,2,3)] of (Symmetric group of order 3! as a permutation group)
+sage: G.socle()
+Subgroup generated by [(1,2,3)] of (Symmetric group of order 3! as a permutation group)
+sage: G.derived_series()
+[Subgroup generated by [(1,2), (1,2,3)] of (Symmetric group of order 3! as a permutation group),
+ Subgroup generated by [(1,2,3)] of (Symmetric group of order 3! as a permutation group),
+ Subgroup generated by [()] of (Symmetric group of order 3! as a permutation group)]
+sage: libgap(G).ChiefSeries()
+[ Group([ (2,3), (1,2,3) ]), Group([ (1,2,3) ]), Group(()) ]
+sage: G.lower_central_series()
+[Subgroup generated by [(1,2), (1,2,3)] of (Symmetric group of order 3! as a permutation group),
+ Subgroup generated by [(1,2,3)] of (Symmetric group of order 3! as a permutation group)]
+sage: G.upper_central_series()
+[Subgroup generated by [()] of (Symmetric group of order 3! as a permutation group)]
+sage: G.character_table()  # Output not guaranteed to exactly match the LMFDB table
+[ 1 -1  1]
+[ 2  0 -1]
+[ 1  1  1]
+sage: 
\ No newline at end of file
diff --git a/lmfdb/tests/snippet_tests/groups/abstract/code-S3-sage_gap.log b/lmfdb/tests/snippet_tests/groups/abstract/code-S3-sage_gap.log
new file mode 100644
index 0000000000..4636a85db1
--- /dev/null
+++ b/lmfdb/tests/snippet_tests/groups/abstract/code-S3-sage_gap.log
@@ -0,0 +1,94 @@
+# snippet evaluation file generated by generate_snippet_tests.py
+sage: G = libgap.eval('SymmetricGroup(3)')
+sage: G.Order()
+6
+sage: G.Exponent()
+6
+sage: G.AutomorphismGroup()
+<group of size 6 with 2 generators>
+sage: G.CompositionSeries()
+[ Group([ (2,3), (1,2,3) ]), Group([ (1,2,3) ]), Group(()) ]
+sage: G.NilpotencyClassOfGroup() if G.IsNilpotentGroup() else -1
+-1
+sage: G.DerivedLength()
+2
+sage: G.IsAbelian()
+false
+sage: G.IsCyclic()
+false
+sage: G.IsElementaryAbelian()
+false
+sage: G.IsMonomialGroup()
+true
+sage: G.IsNilpotentGroup()
+false
+sage: G.IsPerfect()
+false
+sage: G.IsPGroup()
+false
+sage: G.IsPolycyclicGroup()
+true
+sage: G.IsSimpleGroup()
+false
+sage: G.IsSolvableGroup()
+true
+sage: G.IsSupersolvableGroup()
+true
+sage: element_orders = [g.Order() for g in G.Elements()]
+sage: orders = sorted(list(set(element_orders)))
+sage: print("Orders:", orders)
+Orders: [1, 2, 3]
+sage: print("Elements:", [element_orders.count(n) for n in orders], G.Order())
+Elements: [1, 3, 2] 6
+sage: cc_orders = [cc.Representative().Order() for cc in G.ConjugacyClasses()]
+sage: print("Conjugacy classes:", [cc_orders.count(n) for n in orders], len(cc_orders))
+Conjugacy classes: [1, 1, 1] 3
+sage: G.ConjugacyClasses()  # Output not guaranteed to exactly match the LMFDB table
+[ ()^G, (1,2)^G, (1,2,3)^G ]
+sage: G.CharacterDegrees()
+[ [ 1, 2 ], [ 2, 1 ] ]
+sage: GPC = gap.new('PcGroupCode(25,6)'); a = GPC.1; b = GPC.2;
+sage: gap.new('Group( (2,3), (1,3,2) )')
+Group( [ (2,3), (1,3,2) ] )
+sage: gap.new('Group([[[0, -1], [-1, 0]], [[-1, -1], [1, 0]]])')
+Group([ [ [ 0, -1 ], [ -1, 0 ] ], [ [ -1, -1 ], [ 1, 0 ] ] ])
+sage: gap.new('Group([[[ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ]], [[ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ]]])')
+Group([ [ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ], 
+  [ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ] ])
+sage: libgap.TransitiveGroup(3, 2)
+S3
+sage: libgap.TransitiveGroup(6, 2)
+D_6(6) = [3]2
+sage: G.AbelianInvariants()
+[ 2 ]
+sage: G.FactorGroup(G.DerivedSubgroup())
+<pc group with 1 generator>
+sage: G.AbelianInvariantsMultiplier()
+[  ]
+sage: G.CommutatorLength()
+1
+sage: G.AllSubgroups()
+[ Group(()), Group([ (2,3) ]), Group([ (1,2) ]), Group([ (1,3) ]), Group([ (1,2,3) ]), Group([ (1,2,3), (2,3) ]) ]
+sage: G.Center()
+Group(())
+sage: G.DerivedSubgroup()
+Alt( [ 1 .. 3 ] )
+sage: G.FrattiniSubgroup()
+Group(())
+sage: G.FittingSubgroup()
+Group([ (1,2,3) ])
+sage: G.SolvableRadical()
+Sym( [ 1 .. 3 ] )
+sage: G.Socle()
+Group([ (1,2,3) ])
+sage: G.DerivedSeriesOfGroup()
+[ Sym( [ 1 .. 3 ] ), Alt( [ 1 .. 3 ] ), Group(()) ]
+sage: G.ChiefSeries()
+[ Group([ (2,3), (1,2,3) ]), Group([ (1,2,3) ]), Group(()) ]
+sage: G.LowerCentralSeriesOfGroup()
+[ Sym( [ 1 .. 3 ] ), Alt( [ 1 .. 3 ] ) ]
+sage: G.UpperCentralSeriesOfGroup()
+[ Group(()) ]
+sage: G.CharacterTable()  # Output not guaranteed to exactly match the LMFDB table
+CharacterTable( Sym( [ 1 .. 3 ] ) )
+sage: 
\ No newline at end of file
diff --git a/lmfdb/utils/place_code.py b/lmfdb/utils/place_code.py
index 9c5f993c30..86be2a82ed 100644
--- a/lmfdb/utils/place_code.py
+++ b/lmfdb/utils/place_code.py
@@ -29,7 +29,7 @@ def __init__(self, code, item=None, pre="", post=""):
         self.pre, self.post = pre, post
 
         # edit these when adding support for more languages
-        self.comments = {'magma': '//', 'sage': '#',
+        self.comments = {'magma': '//', 'sage': '#', 'sage_gap': '#',
                          'gp': '\\\\', 'pari': '\\\\', 'oscar': '#', 'gap': '#'}
         self.full_names = {"pari": "Pari/GP", "sage": "SageMath", "sage_gap": "SageMath (using Gap)",
                            "magma": "Magma", "oscar": "Oscar", "gap": "Gap"}