diff --git a/JuliaExperimental/gap/gaprat.g b/JuliaExperimental/gap/gaprat.g
deleted file mode 100644
index 70dd047f..00000000
--- a/JuliaExperimental/gap/gaprat.g
+++ /dev/null
@@ -1,23 +0,0 @@
-##############################################################################
-##
-##  gaprat.g
-##
-##  This is experimental code for wrapping GAP's integers and rationals
-##  into Julia objects.
-##  The Julia objects are implemented in 'julia/gaprat.jl'.
-##
-
-
-##############################################################################
-##
-##  Notify the Julia part.
-##
-JuliaIncludeFile( 
-    Filename( DirectoriesPackageLibrary( "JuliaExperimental", "julia" ), 
-    "gaprat.jl" ) );
-
-
-##############################################################################
-##
-#E
-
diff --git a/JuliaExperimental/julia/gaprat.jl b/JuliaExperimental/julia/gaprat.jl
deleted file mode 100644
index 5f44bf85..00000000
--- a/JuliaExperimental/julia/gaprat.jl
+++ /dev/null
@@ -1,383 +0,0 @@
-###############################################################################
-##
-##  gaprat.jl
-##
-##  (copied from Nemo/src/flint/fmpq.jl, and adjusted ...)
-##
-
-module GAPRatModule
-
-import Base: zero, -, one, inv, ==, isless, +, *, //, ^, mod, iszero, string,
-             numerator, denominator, abs, gcd
-
-export GAPRat, get_gaprat_ptr
-
-"""
-    GapObj
-
-> Holds a pointer to an object in the GAP CAS.
-"""
-mutable struct GapObj
-    ptr::Ptr{Cvoid}
-end
-
-struct GAPRat
-    obj::GapObj
-end
-
-function GAPRat(ptr::Ptr{Cvoid})
-    return GAPRat(GapObj(ptr))
-end
-
-function GAPRat(numerator::Int,denominator::Int)
-    x = ccall(:create_rational,Ptr{Cvoid},(Cint,Cint),numerator,denominator)
-    return GAPRat(x)
-end
-
-function get_gaprat_ptr(a::GAPRat)
-    return a.obj.ptr
-end
-#T shall this be used everywhere instead of accessing .obj.ptr?
-
-
-##############################################################################
-##
-##  Julia arithmetic for GAPRats
-##
-
-function zero( a::GAPRat )
-    ptr = ccall( :MyFuncZERO, Ptr{Cvoid},
-                (Ptr{Cvoid},), a.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function -( a::GAPRat )
-    ptr = ccall( :MyFuncAINV, Ptr{Cvoid},
-                (Ptr{Cvoid},), a.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function one( a::GAPRat )
-    ptr = ccall( :MyFuncONE, Ptr{Cvoid},
-                (Ptr{Cvoid},), a.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function inv( a::GAPRat )
-    ptr = ccall( :MyFuncINV, Ptr{Cvoid},
-                (Ptr{Cvoid},), a.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function ==( a::GAPRat, b::GAPRat )
-    return Bool( ccall( :MyFuncEQ, Int,
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, b.obj.ptr ) )
-end
-
-function isless( a::GAPRat, b::GAPRat )
-    return Bool( ccall( :MyFuncLT, Int,
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, b.obj.ptr ) )
-end
-
-function +( a::GAPRat, b::GAPRat )
-    ptr = ccall( :MyFuncSUM, Ptr{Cvoid},
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-#   return GAPRat( SUM( a.obj, b.obj ) )
-end
-
-function -( a::GAPRat, b::GAPRat )
-    ptr = ccall( :MyFuncDIFF, Ptr{Cvoid},
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function *( a::GAPRat, b::GAPRat )
-    ptr = ccall( :MyFuncPROD, Ptr{Cvoid},
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function //( a::GAPRat, b::GAPRat )
-    iszero( b ) && throw( DivideError() )
-    ptr = ccall( :MyFuncQUO, Ptr{Cvoid},
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function ^( a::GAPRat, b::GAPRat )
-    ptr = ccall( :MyFuncPOW, Ptr{Cvoid},
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function ^( a::GAPRat, b::Int )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), b )
-    ptr = ccall( :MyFuncPOW, Ptr{Cvoid},
-                (Ptr{Cvoid}, Int), a.obj.ptr, int_ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function mod( a::GAPRat, b::GAPRat )
-    ptr = ccall( :MyFuncMOD, Ptr{Cvoid},
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function iszero( a::GAPRat )
-    return Bool( ccall( :MyFuncZERO, Ptr{Cvoid},
-                (Ptr{Cvoid},), a.obj.ptr ) == a.obj.ptr )
-end
-
-
-#T defined in Nemo, can we assume that Nemo is loaded? (then add 'using'?)
-# function isone( a::GAPRat )
-#     return GAPRat( ccall( :MyFuncONE, Ptr{Cvoid},(Ptr{Cvoid},), a.obj.ptr ) == a
-# end
-
-#T defined in Nemo
-#T isunit( a::GAPRat ) = ! iszero( a )
-
-
-##############################################################################
-##
-##  ad hoc methods for arithmetic operations with GAPRats and Julia rationals
-##
-
-function ==( a::GAPRat, b::Int )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), b )
-    return Bool( ccall( :MyFuncEQ, Int,
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, int_ptr ) )
-end
-
-function ==( a::Int, b::GAPRat )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), a )
-    return Bool( ccall( :MyFuncEQ, Int,
-                (Ptr{Cvoid}, Ptr{Cvoid}), int_ptr, b.obj.ptr ) )
-end
-
-function ==( a::GAPRat, b::Rational{T} ) where {T <: Integer}
-    return a == GAPRat( numerator(b), denominator(b) )
-end
-
-function ==( a::Rational{T}, b::GAPRat ) where {T <: Integer}
-    return GAPRat( numerator(a), denominator(a) ) == b
-end
-
-
-function isless( a::GAPRat, b::Int )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), b )
-    return Bool( ccall( :MyFuncLT, Int,
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, int_ptr ) )
-end
-
-function isless( a::Int, b::GAPRat )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), a )
-    return Bool( ccall( :MyFuncLT, Int,
-                (Ptr{Cvoid}, Ptr{Cvoid}), int_ptr, a.obj.ptr ) )
-end
-
-function isless( a::GAPRat, b::Rational{T} ) where {T <: Integer}
-    return isless( a, GAPRat( numerator(b), denominator(b) ) )
-end
-
-function isless( a::Rational{T}, b::GAPRat ) where {T <: Integer}
-    return isless( GAPRat( numerator(a), denominator(a) ), b )
-end
-
-
-function +( a::GAPRat, b::Int )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), b )
-    ptr = ccall( :MyFuncSUM, Ptr{Cvoid},
-                (Ptr{Cvoid}, Int), a.obj.ptr, int_ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function +( a::Int, b::GAPRat )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), a )
-    ptr = ccall( :MyFuncSUM, Ptr{Cvoid},
-                (Ptr{Cvoid}, Int), int_ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function +( a::GAPRat, b::Rational{T} ) where {T <: Integer}
-    return a + GAPRat( numerator(b), denominator(b) )
-end
-
-function +( a::Rational{T}, b::GAPRat ) where {T <: Integer}
-    return GAPRat( numerator(a), denominator(a) ) + b
-end
-
-
-function -( a::GAPRat, b::Int )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), b )
-    ptr = ccall( :MyFuncDIFF, Ptr{Cvoid},
-                (Ptr{Cvoid}, Int), a.obj.ptr, int_ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function -( a::Int, b::GAPRat )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), a )
-    ptr = ccall( :MyFuncDIFF, Ptr{Cvoid},
-                (Ptr{Cvoid}, Int), int_ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function -( a::GAPRat, b::Rational{T} ) where {T <: Integer}
-    return a - GAPRat( numerator(b), denominator(b) )
-end
-
-function -( a::Rational{T}, b::GAPRat ) where {T <: Integer}
-    return GAPRat( numerator(a), denominator(a) ) - b
-end
-
-
-function *( a::GAPRat, b::Int )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), b )
-    ptr = ccall( :MyFuncPROD, Ptr{Cvoid},
-                (Ptr{Cvoid}, Int), a.obj.ptr, int_ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function *( a::Int, b::GAPRat )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), a )
-    ptr = ccall( :MyFuncPROD, Ptr{Cvoid},
-                (Ptr{Cvoid}, Int), int_ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function *( a::GAPRat, b::Rational{T} ) where {T <: Integer}
-    return a * GAPRat( numerator(b), denominator(b) )
-end
-
-function *( a::Rational{T}, b::GAPRat ) where {T <: Integer}
-    return GAPRat( numerator(a), denominator(a) ) * b
-end
-
-
-function //( a::GAPRat, b::Int )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), b )
-    ptr = ccall( :MyFuncQUO, Ptr{Cvoid},
-                (Ptr{Cvoid}, Int), a.obj.ptr, int_ptr )
-    return GAPRat( GapObj(ptr) )
-end 
-
-function //( a::Int, b::GAPRat )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), a )
-    ptr = ccall( :MyFuncQUO, Ptr{Cvoid},
-                (Ptr{Cvoid}, Int), int_ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end    
-
-function //( a::GAPRat, b::Rational{T} ) where {T <: Integer}
-    return a // GAPRat( numerator(b), denominator(b) )
-end
-
-function //( a::Rational{T}, b::GAPRat ) where {T <: Integer}
-    return GAPRat( numerator(a), denominator(a) ) // b
-end
-
-
-function mod( a::GAPRat, b::Int )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), b )
-    ptr = ccall( :MyFuncMOD, Ptr{Cvoid},
-                (Ptr{Cvoid}, Int), a.obj.ptr, int_ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function mod( a::Int, b::GAPRat )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), a )
-    ptr = ccall( :MyFuncMOD, Ptr{Cvoid},
-                (Ptr{Cvoid}, Int), int_ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-#T why does the following cause a LoadError?
-# (GAP provides this kind of 'mod')
-# function mod( a::GAPRat, b::Rational{T} ) where {T <: Integer}
-#     return a mod GAPRat( numerator(b), denominator(b) )
-# end
-# 
-# function mod( a::Rational{T}, b::GAPRat ) where {T <: Integer}
-#     return GAPRat( numerator(a), denominator(a) ) mod b
-# end
-
-
-
-#T     function +( a::GAPRat, b::fmpq )  ?
-#T     function +( a::GAPRat, b::fmpz )  ?
-
-#T   and install conversion based on types:
-#T     convert( ::Type{GAPRat}, a::Integer ) = GAPRat( a, 1 )
-#T     convert( ::Type{GAPRat}, a::fmpz ) = GAPRat( a )
-#T     Base.promote_rule(::Type{GAPRat}, ::Type{T}) where {T <: Integer} = GAPRat
-#T     Base.promote_rule(::Type{GAPRat}, ::Type{Rational{T}}) where {T <: Integer} = GAPRat
-
-#T - Support the conversion from GAPRat to Rational{BigInt}:
-#T     function Rational( a::GAPRat ) ... end
-#T     convert( ::Type{Rational{BigInt}}, a::GAPRat ) = Rational( a )
-
-
-##############################################################################
-##
-##  some functions for GAP rationals:
-##
-
-function numerator( a::GAPRat )
-    ptr = ccall( :NUM_RAT, Ptr{Cvoid},
-                (Ptr{Cvoid},), a.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function denominator( a::GAPRat )
-    ptr = ccall( :DEN_RAT, Ptr{Cvoid},
-                (Ptr{Cvoid},), a.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-#T This works only for GAP integers, GAP has no C function for GAP rationals?
-function abs( a::GAPRat )
-    ptr = ccall( :AbsInt, Ptr{Cvoid},
-                (Ptr{Cvoid},), a.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function gcd( a::GAPRat, b::GAPRat )
-    ptr = ccall( :GcdInt, Ptr{Cvoid},
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, b.obj.ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function gcd( a::GAPRat, b::Int )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), b )
-    ptr = ccall( :GcdInt, Ptr{Cvoid},
-                (Ptr{Cvoid}, Ptr{Cvoid}), a.obj.ptr, int_ptr )
-    return GAPRat( GapObj(ptr) )
-end
-
-function gcd( a::Int, b::GAPRat )
-    int_ptr = ccall( :ObjInt_Int, Ptr{Cvoid}, (Int,), a )
-    return ccall( :GcdInt, Ptr{Cvoid},
-                (Ptr{Cvoid}, Ptr{Cvoid}), int_ptr, b.obj.ptr )
-end
-
-#T     function <<( a::GAPRat, b::Int ) ... end
-#T     function >>( a::GAPRat, b::Int ) ... end
-
-function Base.hash( a::GAPRat, h::UInt )
-    return _hash_integer( numerator( a ),
-                          _hash_integer( denominator( a ), h ) )
-end
-
-#T - Does it make sense to support a 'show' method?
-
-#T how to create a Julia string from the GAPRat?
-function string( a::GAPRat )
-   return "<a GAPRat object>"
-end
-
-#T - If we want to put GAPRat objects into Nemo matrices (?)
-#T   then support also 'divexact' (add ad hoc methods)
-
-end
-
diff --git a/JuliaExperimental/read.g b/JuliaExperimental/read.g
index 4821aa20..47cc77e9 100644
--- a/JuliaExperimental/read.g
+++ b/JuliaExperimental/read.g
@@ -27,10 +27,6 @@ if JuliaImportPackage( "Nemo" ) then
 fi;
 
 
-# GAP integers and rationals in Julia.
-ReadPackage( "JuliaExperimental", "gap/gaprat.g");
-
-
 # Julia permutations
 ReadPackage( "JuliaExperimental", "gap/gapperm.g");
 
diff --git a/JuliaExperimental/src/JuliaExperimental.c b/JuliaExperimental/src/JuliaExperimental.c
index a65c2f2f..b660a7ac 100644
--- a/JuliaExperimental/src/JuliaExperimental.c
+++ b/JuliaExperimental/src/JuliaExperimental.c
@@ -4,31 +4,10 @@
 
 #include "JuliaInterface.h" /* JuliaInterface header (includes all the gappy stuff) */
 
-#include "gap_macros.c"
-
-
-Obj FuncJuliaGAPRatInt(Obj self, Obj integer)
-{
-    jl_module_t *   module_t = get_module_from_string("GAPRatModule");
-    jl_function_t * func = jl_get_function(module_t, "GAPRat");
-    jl_value_t *    rat_obj =
-        jl_call1(func, jl_box_voidpointer((void *)integer));
-    return NewJuliaObj(rat_obj);
-}
-
-Obj FuncJuliaObjGAPRat(Obj self, Obj gap_rat)
-{
-    jl_module_t *   module_t = get_module_from_string("GAPRatModule");
-    jl_function_t * func = jl_get_function(module_t, "get_gaprat_ptr");
-    void *          rat_obj =
-        jl_unbox_voidpointer(jl_call1(func, GET_JULIA_OBJ(gap_rat)));
-    return (Obj)rat_obj;
-}
+#include <src/compiled.h>
 
 // Table of functions to export
 static StructGVarFunc GVarFuncs[] = {
-    GVAR_FUNC(JuliaGAPRatInt, 1, "number"),
-    GVAR_FUNC(JuliaObjGAPRat, 1, "obj"),
 
     { 0 } /* Finish with an empty entry */
 
diff --git a/JuliaExperimental/src/gap_macros.c b/JuliaExperimental/src/gap_macros.c
deleted file mode 100644
index ed2fcf0f..00000000
--- a/JuliaExperimental/src/gap_macros.c
+++ /dev/null
@@ -1,81 +0,0 @@
-// Functions for accessing GAP macros
-// This file should be completely obsolete
-// once LibGap is completed
-
-#include <src/compiled.h>
-
-// Provide C functions that can call the functions
-// in GAP's kernel tables (see GAP's 'src/ariths.h').
-// (not yet: _MUT variants of ZERO, AINV, ONE, INV, and IN, LQUO, COMM)
-Obj MyFuncZERO(Obj a)
-{
-    return ZERO(a);
-}
-
-Obj MyFuncAINV(Obj a)
-{
-    return AINV(a);
-}
-
-Obj MyFuncONE(Obj a)
-{
-    return ONE(a);
-}
-
-Obj MyFuncINV(Obj a)
-{
-    return INV(a);
-}
-
-int MyFuncEQ(Obj a, Obj b)
-{
-    return EQ(a, b);
-}
-
-int MyFuncLT(Obj a, Obj b)
-{
-    return LT(a, b);
-}
-
-Obj MyFuncSUM(Obj a, Obj b)
-{
-    return SUM(a, b);
-}
-
-Obj MyFuncDIFF(Obj a, Obj b)
-{
-    return DIFF(a, b);
-}
-
-Obj MyFuncPROD(Obj a, Obj b)
-{
-    return PROD(a, b);
-}
-
-Obj MyFuncQUO(Obj a, Obj b)
-{
-    return QUO(a, b);
-}
-
-Obj MyFuncPOW(Obj a, Obj b)
-{
-    return POW(a, b);
-}
-
-Obj MyFuncMOD(Obj a, Obj b)
-{
-    return MOD(a, b);
-}
-
-Obj create_rational(int numerator, int denominator)
-{
-    Obj numerator_obj = ObjInt_Int(numerator);
-    Obj denominator_obj = ObjInt_Int(denominator);
-
-    Obj rational_obj = NewBag(T_RAT, 2 * sizeof(Obj));
-
-    SET_NUM_RAT(rational_obj, numerator_obj);
-    SET_DEN_RAT(rational_obj, denominator_obj);
-
-    return rational_obj;
-}
diff --git a/JuliaExperimental/tst/gaprat.tst b/JuliaExperimental/tst/gaprat.tst
deleted file mode 100644
index e33bf623..00000000
--- a/JuliaExperimental/tst/gaprat.tst
+++ /dev/null
@@ -1,102 +0,0 @@
-#############################################################################
-##
-#W  gaprat.tst         GAP 4 package JuliaExperimental          Thomas Breuer
-##
-gap> START_TEST( "gaprat.tst" );
-
-##
-gap> x:= JuliaGAPRatInt( 3 );;
-gap> y:= JuliaGAPRatInt( 4 );;
-gap> JuliaObjGAPRat( x );
-3
-
-##  create GAPRat objects in Julia
-gap> gaprat:= JuliaFunction( "GAPRat", "GAPRatModule" );;
-gap> JuliaObjGAPRat( gaprat( 1, 2 ) );
-1/2
-
-##  test arithmetic operations with GAPRats
-gap> zero:= Julia.Base.zero( x );;
-gap> JuliaObjGAPRat( zero );
-0
-gap> JuliaObjGAPRat( Julia.Base.( "-" )( x ) );
--3
-gap> JuliaObjGAPRat( Julia.Base.one( x ) );
-1
-gap> JuliaObjGAPRat( Julia.Base.inv( x ) );
-1/3
-gap> ConvertedFromJulia( Julia.Base.( "==" )( x, x ) );
-true
-gap> ConvertedFromJulia( Julia.Base.( "==" )( x, y ) );
-false
-gap> ConvertedFromJulia( Julia.Base.isless( x, y ) );
-true
-gap> ConvertedFromJulia( Julia.Base.isless( y, x ) );
-false
-gap> ConvertedFromJulia( Julia.Base.isless( x, x ) );
-false
-gap> JuliaObjGAPRat( Julia.Base.( "+" )( x, y ) );
-7
-gap> JuliaObjGAPRat( Julia.Base.( "-" )( x, y ) );
--1
-gap> JuliaObjGAPRat( Julia.Base.( "*" )( x, y ) );
-12
-gap> JuliaObjGAPRat( Julia.Base.( "//" )( x, x ) );
-1
-gap> JuliaObjGAPRat( Julia.Base.( "^" )( x, y ) );
-81
-gap> JuliaObjGAPRat( Julia.Base.( "^" )( x, 2 ) );
-9
-gap> JuliaObjGAPRat( Julia.Base.( "mod" )( x, y ) );
-3
-gap> ConvertedFromJulia( Julia.Base.iszero( x ) );
-false
-gap> ConvertedFromJulia( Julia.Base.iszero( zero ) );
-true
-gap> ConvertedFromJulia( Julia.Base.( "==" )( x, x ) );
-true
-gap> ConvertedFromJulia( Julia.Base.( "==" )( x, y ) );
-false
-gap> ConvertedFromJulia( Julia.Base.isless( x, y ) );
-true
-gap> ConvertedFromJulia( Julia.Base.isless( y, x ) );
-false
-gap> ConvertedFromJulia( Julia.Base.isless( x, x ) );
-false
-
-##  test binary arithmetic operations with GAPRats and Julia integers
-gap> j:= ConvertedToJulia( 20 );;
-gap> JuliaObjGAPRat( Julia.Base.( "+" )( x, j ) );
-23
-gap> JuliaObjGAPRat( Julia.Base.( "+" )( j, x ) );
-23
-gap> JuliaObjGAPRat( Julia.Base.( "-" )( x, j ) );
--17
-gap> JuliaObjGAPRat( Julia.Base.( "-" )( j, x ) );
-17
-gap> JuliaObjGAPRat( Julia.Base.( "*" )( x, j ) );
-60
-gap> JuliaObjGAPRat( Julia.Base.( "*" )( j, x ) );
-60
-gap> JuliaObjGAPRat( Julia.Base.( "//" )( x, j ) );
-3/20
-gap> JuliaObjGAPRat( Julia.Base.( "//" )( j, x ) );
-20/3
-gap> JuliaObjGAPRat( Julia.Base.( "^" )( x, j ) );
-3486784401
-gap> # JuliaObjGAPRat( Julia.Base.( "^" )( j, x ) );  # too large ...
-gap> JuliaObjGAPRat( Julia.Base.( "mod" )( x, j ) );
-3
-gap> JuliaObjGAPRat( Julia.Base.( "mod" )( j, x ) );
-2
-
-##  test arithmetic operations with GAPRats and Julia rationals
-#T TODO!
-
-##  test the Julia functions for GAPRats
-gap> JuliaObjGAPRat( Julia.Base.gcd( x, y ) );
-1
-
-##
-gap> STOP_TEST( "gaprat.tst", 1 );
-
diff --git a/JuliaExperimental/tst/testall.g b/JuliaExperimental/tst/testall.g
index 5a555ad0..1cfc212d 100644
--- a/JuliaExperimental/tst/testall.g
+++ b/JuliaExperimental/tst/testall.g
@@ -8,7 +8,6 @@ LoadPackage( "JuliaExperimental" );
 
 pairs:= [
   [ "gapnemo.tst", [ "Nemo" ] ],
-  [ "gaprat.tst", [] ],
   [ "hnf.tst", [ "Nemo" ] ],
 # [ "numfield.tst", [ "Nemo" ] ],
   [ "realcyc.tst", [ "Nemo" ] ],