Undergraduate Universities

Explore UK universities below or take our new Find Your UK University Quiz to quickly find the best matches for you!

Search Undergraduate Universities

Academic matches are based on minimum US entry requirements.

London Metropolitan University

Based in England’s historic capital city, London Metropolitan University has a rich history of education with its roots dating back to 1848. Taking its current form following a merger of two well-renowned universities in 2002, it offers a wide range of courses across two London campuses.

{"map_options":{"center_lat":"55.8619473","center_lng":"-4.2423246","zoom":5,"map_type_id":"ROADMAP","center_by_nearest":false,"fit_bounds":true,"center_circle_fillcolor":"#8CAEF2","center_circle_strokecolor":"#8CAEF2","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https://www.wpleaflet.com/wp-content/plugins/wp-leaflet-maps-pro/assets/images//default_marker.png","draggable":true,"scroll_wheel":"false","gesture":"auto","marker_default_icon":"https://theukstudyexpert.com/wp-content/plugins/wp-google-map-gold/assets/images/icons/marker_default_icon.png","infowindow_setting":"<div class=\"fc-item-box fc-item-no-padding\">\n    {marker_image}</p>\n<div class=\"fc-itemcontent-padding\">\n<div class=\"fc-item-padding-content_20\">\n<div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">{marker_category}</div>\n<div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{marker_title}</div>\n<div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\n                {marker_message}<br />\n<strong>Course - </strong> {course}<br />\n<strong>Type of College - </strong> {type-of-college}<br />\n<strong>Program Type - </strong> {program-type}\n            </div>\n</p></div>\n</p></div>\n</div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    {post_featured_image}\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"{post_link}\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                {post_excerpt}\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","infowindow_skin":{"name":"udine","type":"infowindow","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    {marker_image}\r\n    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n        &lt;div class=&quot;fc-item-padding-content_20&quot;&gt;\r\n            &lt;div class=&quot;fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center&quot;&gt;{marker_category}&lt;/div&gt;\r\n            &lt;div class=&quot;fc-item-title fc-item-primary-text-color fc-text-center&quot;&gt;{marker_title}&lt;/div&gt;\r\n            &lt;div class=&quot;fc-item-content fc-item-body-text-color fc-item-top-space&quot;&gt;\r\n                {marker_message}&lt;br&gt;\r\n&lt;strong&gt;Course - &lt;/strong&gt; {course}&lt;br&gt;\r\n&lt;strong&gt;Type of College - &lt;/strong&gt; {type-of-college}&lt;br&gt;\r\n&lt;strong&gt;Program Type - &lt;/strong&gt; {program-type}\r\n            &lt;/div&gt;\r\n\r\n        &lt;/div&gt;\r\n    &lt;/div&gt;\r\n&lt;/div&gt;"},"infowindow_post_skin":{"name":"udine","type":"post","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    {post_featured_image}\r\n    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n        &lt;div class=&quot;fc-item-padding-content_20&quot;&gt;\r\n&lt;a href=&quot;{post_link}&quot; class=&quot;fc-item-title fc-item-primary-text-color fc-text-center&quot;&gt;{post_title}&lt;/a&gt;\r\n            &lt;div class=&quot;fc-item-content fc-item-body-text-color fc-item-top-space&quot;&gt;\r\n                {post_excerpt}\r\n            &lt;/div&gt;\r\n        &lt;/div&gt;\r\n    &lt;/div&gt;\r\n&lt;/div&gt;"},"infowindow_drop_animation":true,"close_infowindow_on_map_click":true,"default_infowindow_open":false,"infowindow_open_event":"click","listing_infowindow_open_event":"click","is_mobile":false,"infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":true,"full_screen_control":true,"search_control":true,"exclude_fields":["{%_custom_priority_meta_key%}","{post_featured_image}","{post_link}"],"zoom_control":true,"map_type_control":true,"street_view_control":true,"locateme_control":true,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"BOTTOM_LEFT","search_control_position":"BOTTOM_LEFT","locateme_control_position":"BOTTOM_LEFT","zoom_control_position":"LEFT_BOTTOM","map_type_control_position":"BOTTOM_LEFT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"BOTTOM_LEFT","map_control":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":"5","url_filters":true,"doubleclickzoom":true,"current_post_only":false,"search_placeholder":"Enter a search term (i.e. degree interest, city, country, etc.)...","bound_map_after_filter":true,"display_reset_button":false,"map_reset_button_text":"Reset","height":"650"},"places":[{"source":"post","title":"University of Strathclyde","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Strathclyde\" width=\"300\" height=\"300\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/09/Untitled-design-82.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/university-of-strathclyde/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Strathclyde</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                The University of Strathclyde is Scotland\u2019s third largest university. We are a truly global university providing cutting-edge education to more than 30,000 students from over 140 different countries around the world.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"The University of Strathclyde is Scotland\u2019s third largest university. We are a truly global university providing cutting-edge education to more than 30,000 students from over 140 different countries around the world.","address":"16 Richmond St, Glasgow G1 1XQ, UK","location":{"lat":"55.8619473","state":"Scotland","country":"United Kingdom","lng":"-4.2423246","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/university-of-strathclyde/","zoom":5,"extra_fields":{"post_excerpt":"The University of Strathclyde is Scotland\u2019s third largest university. We are a truly global university providing cutting-edge education to more than 30,000 students from over 140 different countries around the world.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/09/DSC_1201.jpg\" alt=\"Strathclyde Sport\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/09/Campus-Building.jpg\" alt=\"Campus-Building\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/09/Strathclyde.jpg\" alt=\"Strathclyde\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact University of Strathclyde\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong>\u00a016 Richmond Street, Glasgow, Scotland, G1 1XQ, United Kingdom</p><p><strong>Website:</strong>\u00a0<a href=\"https://www.strath.ac.uk/\" rel=\"noopener\">https://strath.ac.uk/</a></p><h3>Overview</h3><p>The University of Strathclyde is Scotland\u2019s third largest university. We are a truly global university providing cutting-edge education to more than 30,000 students from over 140 different countries around the world.</p><p>Originally founded in 1796 as a place of useful learning, we\u2019re a leading technological University offering a wide range of fields of study.</p><p>We have over 200 undergraduate degree and a further 200 Postgraduate Degrees programs across 4 Faculties: Business (our Business School is triple accredited including AACSB), Engineering, Humanities &amp; Social Sciences and Science.</p><p><strong>Population:\u00a0</strong>30,000</p><p><strong>Campus Type:\u00a0</strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>Located in the heart of Glasgow, Scotland\u2019s largest and friendliest city.</p></li><li><p>30,000 students from over 140 countries</p></li></ul>\t\t\n\t\t<h3>Videos</h3>https://www.youtube.com/watch?v=Q8N3GLMzx4chttps://www.youtube.com/watch?v=bsypQ47E3TQhttps://www.youtube.com/watch?v=HgpwCXUfeishttps://www.youtube.com/watch?v=bdxx0ol93Dg\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>We have a test-flexible admissions policy for US students. We invite interested students to submit their application directly or through UCAS for their chosen course, along with their current or completed high school diploma, which we will consider with a minimum 3.0 GPA.</p><p><br />Candidates are invited to submit any standardized testing, and we will consider the following:<br /><br /></p><ul><li>SAT: 1200 (600 in each component)/ ACT: 27 plus 2 AP exams with scores of 4+<br /><br />OR<br /><br /></li><li>3 AP exams with scores of 4+</li></ul><p><br />Where candidates do not have access to or have not taken standardized testing, we will consider strong academic performance demonstrated within the high school diploma, for example AP or Honors classes.<br /><br /></p><p>Entry to some degree programmes may require the completion of AP classes or exams, or Honors classes with grades A/B in specific subjects eg Calculus and Physics for Engineering.<br /><br />Please contact the academic department or International Office if you are not sure.</p><p><br />We do not superscore the SAT or consider the optional essay.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<p>BA Hons Accounting<br />BA Hons Accounting &amp; Business Analysis and Technology<br />BA Hons Accounting &amp; Business Enterprise<br />BA Accounting &amp; Business Law<br />BA Accounting &amp; Economics<br />BA Joint Hons Accounting &amp; Finance<br />BA Hons Accounting &amp; Hospitality and Tourism Management<br />BA Joint Hons Accounting &amp; Human Resource Management<br />BA Accounting &amp; Marketing<br />MEng Aero-Mechanical Engineering<br />BEng Aero-Mechanical Engineering<br />MSci Applied Chemistry &amp; Chemical Engineering<br />BSc Hons Architectural Studies<br />MSci Biochemistry<br />BSc Hons Biochemistry &amp; Immunology<br />BSc Hons Biochemistry &amp; Microbiology<br />BSc Hons Biochemistry &amp; Pharmacology<br />BEng Biomedical Engineering<br />MEng Biomedical Engineering<br />BSc Hons Biomedical Science<br />BSc Hons Biomolecular Sciences<br />BA Hons Business<br />BBA Hons Business Administration<br />BA Hons Business Analysis &amp; Technology<br />BA Hons Business Analysis and Technology &amp; Business Enterprise<br />BA Hons Business Analysis and Technology &amp; Business Law<br />BA Hons Business Analysis and Technology &amp; Economics<br />BA Hons Business Analysis and Technology &amp; Finance<br />BA Hons Business Analysis and Technology &amp; Hospitality and Tourism Management<br />BA Hons Business Analysis and Technology &amp; Human Resource Management<br />BA Hons Business Analysis and Technology &amp; Marketing<br />BA Hons Business Analysis and Technology &amp; Mathematics and Statistics<br />BA Hons Business Enterprise<br />BA Hons Business Enterprise &amp; Business Law<br />BA Hons Business Enterprise &amp; Economics<br />BA Hons Business Enterprise &amp; Finance<br />BA Hons Business Enterprise &amp; Hospitality and Tourism Management<br />BA Hons Business Enterprise &amp; Human Resource Management<br />BA Hons Business Enterprise &amp; Marketing<br />BEng Chemical Engineering<br />MEng Chemical Engineering<br />MChem Chemistry<br />MChem Chemistry with Data Science<br />MChem Chemistry with Drug Discovery<br />MChem Chemistry with Teaching<br />MEng Civil &amp; Environmental Engineering<br />BEng Civil &amp; Environmental Engineering<br />MEng Civil Engineering<br />BEng Civil Engineering<br />MEng Computer &amp; Electronic Systems<br />BEng Computer &amp; Electronic Systems<br />MEng Computer &amp; Electronic Systems with International Study<br />MEng Computer Science<br />BSc Hons Computer Science<br />BSc Hons Data Analytics<br />BA Hons Economics<br />BA Hons Economics &amp; Business Law<br />BA Hons Economics &amp; Finance<br />BA Joint Hons Economics &amp; Human Resource Management<br />BA Joint Hons Economics &amp; Marketing<br />BA Economics &amp; Psychology<br />BA Joint Hons Economics, Mathematics &amp; Statistics<br />BA Hons Education &amp; Economics<br />BA Hons Education &amp; English<br />BA Hons Education &amp; English and Creative Writing<br />BA Hons Education &amp; French<br />BA Hons Education &amp; History<br />BA Hons Education &amp; Human Resource Management<br />BA Hons Education &amp; Journalism, Media and Communication<br />BA Hons Education &amp; Law<br />BA Hons Education &amp; Politics and International Relations<br />BA Hons Education &amp; Psychology<br />BA Hons Education &amp; Social Policy<br />BA Hons Education &amp; Spanish<br />MEng Electrical &amp; Mechanical Engineering<br />BEng Hons Electrical &amp; Mechanical Engineering<br />MEng Electrical &amp; Mechanical Engineering with International Study<br />MEng Electrical Energy Systems<br />MEng Electronic &amp; Digital Systems<br />BEng Hons Electronic &amp; Electrical Engineering<br />MEng Electronic &amp; Electrical Engineering<br />MEng Electronic &amp; Electrical Engineering with Business Studies<br />MEng Electronic &amp; Electrical Engineering with International Study<br />BA Hons English<br />BA Hons English &amp; Creative Writing<br />BA Joint Hons English &amp; French<br />BA Joint Hons English &amp; History<br />BA Joint Hons English &amp; Human Resource Management<br />BA Hons English &amp; Journalism, Media and Communication<br />BA Joint Hons English &amp; Law<br />BA Joint Hons English &amp; Politics and International Relations<br />BA Joint Hons English &amp; Psychology<br />BA Hons English &amp; Social Policy<br />BA Joint Hons English &amp; Spanish<br />BA Hons English and Creative Writing &amp; French<br />BA Hons English and Creative Writing &amp; History<br />BA Hons English and Creative Writing &amp; Human Resource Management<br />BA Hons English and Creative Writing &amp; Journalism, Media and Communication<br />BA Hons English and Creative Writing &amp; Law<br />BA Hons English and Creative Writing &amp; Politics and International Relations<br />BA Hons English and Creative Writing &amp; Psychology<br />BA Hons English and Creative Writing &amp; Social Policy<br />BA Hons English and Creative Writing &amp; Spanish<br />BA Hons Finance<br />BA Hons Finance &amp; Business Law<br />BA Hons Finance &amp; Hospitality and Tourism Management<br />BA Joint Hons Finance &amp; Human Resource Management<br />BA Joint Hons Finance &amp; Marketing<br />BA Joint Hons Finance &amp; Mathematics and Statistics<br />MChem Forensic &amp; Analytical Chemistry<br />BA Hons French &amp; Economics<br />BA Joint Hons French &amp; History<br />BA Hons French &amp; Hospitality and Tourism Management<br />BA Joint Hons French &amp; Human Resource Management<br />BA Hons French &amp; Journalism, Media and Communication<br />BA Joint Hons French &amp; Law<br />BA Joint Hons French &amp; Marketing<br />BA Hons French &amp; Politics and International Relations<br />BA Joint Hons French &amp; Psychology<br />BA Hons French &amp; Social Policy<br />BA Joint Hons French &amp; Spanish<br />BA Hons History<br />BA Hons History &amp; Economics<br />BA Joint Hons History &amp; Human Resource Management<br />BA Hons History &amp; Journalism, Media and Communication<br />BA Joint Hons History &amp; Law<br />BA Joint Hons History &amp; Politics and International Relations<br />BA History &amp; Psychology<br />BA Hons History &amp; Social Policy<br />BA Joint Hons History &amp; Spanish<br />BA Hons Hospitality &amp; Tourism Management<br />BA Hons Hospitality and Tourism Management &amp; Business Law<br />BA Hons Hospitality and Tourism Management &amp; Human Resource Management<br />BA Hons Hospitality and Tourism Management &amp; Marketing<br />BA Hons Human Resource Management<br />BA Hons Human Resource Management &amp; Business Law<br />BA Joint Hons Human Resource Management &amp; Marketing<br />BA Joint Hons Human Resource Management &amp; Psychology<br />MSci Immunology<br />BSc Hons Immunology &amp; Microbiology<br />BSc Hons Immunology &amp; Pharmacology<br />BA Hons International Business<br />MBus International Business with a Modern Language<br />BA Hons Journalism, Media and Communication &amp; Economics<br />BA Hons Journalism, Media and Communication &amp; Human Resource Management<br />BA Hons Journalism, Media and Communication &amp; Law<br />BA Hons Journalism, Media and Communication &amp; Politics and International Relations<br />BA Hons Journalism, Media and Communication &amp; Psychology<br />BA Hons Journalism, Media and Communication &amp; Social Policy<br />BA Hons Journalism, Media and Communication &amp; Spanish<br />LLB Law<br />BA Hons Law &amp; Economics<br />BA Hons Law &amp; Human Resource Management<br />BA Hons Law &amp; Politics and International Relations<br />BA Joint Hons Law &amp; Psychology<br />BA Hons Law &amp; Social Policy<br />BA Joint Hons Law &amp; Spanish<br />LLB Law (Clinical) (Graduate Entry)<br />LLB Law (Graduate Entry)<br />LLB Hons Law with French<br />LLB Hons Law with Spanish<br />MEng Manufacturing Engineering with Management<br />BEng Hons Manufacturing Engineering with Management<br />BA Hons Marketing<br />BA Hons Marketing &amp; Business Law<br />BA Joint Hons Marketing &amp; Psychology<br />BSc Mathematics<br />MMath Mathematics<br />BSc Hons Mathematics &amp; Computer Science<br />BSc Hons Mathematics &amp; Physics<br />BSc Hons Mathematics with Teaching<br />BSc Hons Mathematics, Statistics &amp; Accounting<br />BSc Hons Mathematics, Statistics &amp; Business Analysis<br />BSc Hons Mathematics, Statistics &amp; Economics<br />BSc Hons Mathematics, Statistics &amp; Finance<br />BEng Hons Mechanical Engineering<br />MEng Mechanical Engineering<br />BEng Hons Mechanical Engineering with International Study<br />MEng Mechanical Engineering with International Study<br />MSci Microbiology<br />BSc Hons Microbiology &amp; Pharmacology<br />BEng Hons Naval Architecture &amp; Marine Engineering<br />MEng Naval Architecture &amp; Marine Engineering<br />MEng Naval Architecture with High Performance Marine Vehicles<br />Beng Hons Naval Architecture with High Performance Marine Vehicles<br />BEng Hons Naval Architecture with Ocean Engineering<br />MEng Naval Architecture with Ocean Engineering<br />MSci Pharmacology<br />MPharm Pharmacy<br />BSc Hons Physics<br />MPhys Physics<br />MPhys Physics with Advanced Research<br />BSc Hons Physics with Teaching<br />BA Hons Politics &amp; International Relations<br />BA Hons Politics and International Relations &amp; Economics<br />BA Hons Politics and International Relations &amp; Human Resource Management<br />BA Hons Politics and International Relations &amp; Psychology<br />BA Hons Politics and International Relations &amp; Social Policy<br />BA Hons Politics and International Relations &amp; Spanish<br />BA Hons Primary Education<br />MSci Product Design &amp; Innovation<br />BSc Hons Product Design &amp; Innovation<br />MEng Product Design Engineering<br />BEng Hons Product Design Engineering<br />BSc Hons Prosthetics &amp; Orthotics<br />BA Hons Psychology<br />BSc Hons Psychology &amp; Counselling<br />BA Hons Psychology &amp; Economics<br />BA Hons Psychology &amp; Human Resource Management<br />BA Joint Hons Psychology &amp; Mathematics<br />BA Hons Psychology &amp; Social Policy<br />BA Joint Hons Psychology &amp; Spanish<br />BA Hons Social Policy &amp; Economics<br />BA Hons Social Policy &amp; Human Resource Management<br />BA Hons Social Policy &amp; Spanish<br />BA Hons Social Work<br />BSc Hons Software Engineering<br />BA Hons Spanish &amp; Economics<br />BA Hons Spanish &amp; Hospitality and Tourism Management<br />BA Hons Spanish &amp; Human Resource Management<br />BA Joint Hons Spanish &amp; Marketing<br />BSc Hons Speech &amp; Language Pathology<br />BSc Hons Sport &amp; Physical Activity<br />MEng Sports Design Engineering<br />BEng Hons Sports Design Engineering</p>\n\t\t\t<a href=\"https://www.strath.ac.uk/courses/undergraduate/\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>A minimum GPA of 3.0 or above on a 4.0 scale. Some courses may accept a lower GPA and will take into consideration your supporting documents. Please contact us if you are in any doubt. Applications are made directly to Strathclyde through the course web page for postgraduate study. If you wish to apply for a research degree you\u2019d normally have to have a Masters degree and some experience of research work.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<p>5G Advanced Communications<br />Actuarial Science<br />MArch Advanced Architectural Design<br />Advanced Biochemistry<br />Advanced Chemical &amp; Process Engineering (distance learning)<br />Advanced Chemical Engineering<br />Advanced Chemical Engineering (January intake)<br />Advanced Computer Science<br />Advanced Computer Science (January start)<br />Advanced Computer Science with Artificial Intelligence<br />Advanced Computer Science with Data Science<br />Advanced Computer Science with Data Science (January start)<br />Advanced Computer Science with Software Engineering<br />Advanced Computer Science with Software Engineering (January start)<br />Advanced Construction Technologies &amp; BIM<br />Advanced Construction Technologies and BIM (January)<br />Advanced Drug Delivery<br />Advanced Electrical Power &amp; Energy Systems<br />Advanced Immunology<br />Advanced Manufacturing: Technology &amp; Systems<br />Advanced Materials Engineering<br />Advanced Mechanical Engineering<br />Advanced Mechanical Engineering (January intake)<br />Advanced Mechanical Engineering (Online Learning)<br />Advanced Mechanical Engineering with Aerospace<br />Advanced Mechanical Engineering with Aerospace (January intake)<br />Advanced Mechanical Engineering with Energy Systems<br />Advanced Mechanical Engineering with Energy Systems (January)<br />Advanced Mechanical Engineering with Industrial Placement<br />Advanced Mechanical Engineering with Materials<br />Advanced Naval Architecture<br />Advanced Naval Architecture (January)<br />Advanced Pharmaceutical Manufacturing<br />Advanced Pharmacology<br />Advanced Physics<br />Applied Economics<br />Applied Economics (Online)<br />Applied Educational &amp; Social Research<br />Applied Gender Studies<br />Applied Physics<br />Applied Statistics<br />Applied Statistics (online)<br />Applied Statistics in Finance<br />Applied Statistics in Finance (online)<br />Applied Statistics in Health Sciences<br />Applied Statistics in Health Sciences (online)<br />Applied Translation<br />Applied Translation &amp; Interpreting<br />MArch Architectural Design (International)<br />Architectural Design for the Conservation of Built Heritage<br />Artificial Intelligence &amp; Applications<br />Autism<br />Autonomous Robotic Intelligent Systems<br />Biomedical Engineering<br />Biomedical Engineering (January intake)<br />Biomedical Sciences<br />Business &amp; Management<br />Business &amp; Management (January)<br />Business Analysis &amp; Consulting<br />Business Analysis &amp; Consulting (January)<br />Cancer Therapies<br />Chemical Technology &amp; Management (Distance Learning)<br />Chemistry with Artificial Intelligence<br />Chemistry with Data Science<br />Child &amp; Youth Care Studies by Distance Learning<br />Children &amp; Young People in Conflict with the Law<br />Civil Engineering<br />Civil Engineering (January intake)<br />Clinical Health Psychology<br />Clinical Pharmacy<br />Construction Law<br />Counselling &amp; Psychotherapy<br />Creative Writing<br />Criminal Justice &amp; Penal Change<br />Crimonology &amp; Social Policy<br />Cyber Security<br />Data Analytics<br />Data Science for Politics &amp; Policymaking<br />Design Engineering<br />Design Engineering with Advanced Product Development<br />Design Engineering with Sustainability<br />Digital Health Systems<br />Digital Journalism<br />Digital Manufacturing<br />Digital Marketing Management<br />Digital Marketing Management (January)<br />Diplomacy &amp; International Security<br />Early Years Pedagogue<br />Economics &amp; Finance<br />Economics &amp; Policy of Energy &amp; Climate Change<br />Economics &amp; Policy of Energy &amp; Climate Change (Online)<br />Education (international)<br />Education (international) (January)<br />Education Studies<br />Education Studies (January)<br />Educational Leadership<br />Electrical Power &amp; Energy Systems<br />Electronic &amp; Electrical Engineering<br />Energy Systems Innovation<br />Engineering Management for Process Excellence<br />Engineering Project Management (Online)<br />Entrepreneurship Engineering &amp; Technology<br />Environemental Engineering<br />Environemental Engineering (January Intake)<br />Environemental Engineering (Distance Learning)<br />Finance<br />Finance (January)<br />Financial Technology<br />Forensic Science<br />Global Environmental Law &amp; Governance<br />Health &amp; Social Policy<br />Health Analysis, Policy &amp; Management<br />Health History<br />Historical Studies<br />Human Resource Management<br />Human Resource Management (part-time)<br />Human Rights Law<br />Hydrogeology<br />Hydrogeology (Online)<br />Industrial Biotechnology<br />Information &amp; Library Studies<br />Information Management<br />Interdisciplinary English Studies<br />International Accounting &amp; Finance<br />International Accounting &amp; Finance (January)<br />International Banking &amp; Finance<br />International Commercial Law<br />International Commercial Law (January)<br />International Human Resource Management<br />International Management<br />International Management (January)<br />International Marketing<br />International Master Project Management<br />International Relations<br />International Relations (January)<br />International Social Welfare<br />Investment &amp; Finance<br />Investment &amp; Finance (January)<br />Law<br />Law (January)<br />Law, Technology &amp; Innovation<br />Machine Learning &amp; Deep Learning<br />Machine Learning &amp; Deep Learning (January)<br />Marine Engineering<br />Marine Engineering (January)<br />Marine Engineering with Specialisation in Autonomous Marine Vehicles<br />Marketing<br />Marketing (January)<br />Master of Business Administration (MBA)<br />MBA with Specialisation in Sustainable Energy Futures<br />Mechatronics &amp; Automation<br />Mechatronics &amp; Automation (January)<br />Media &amp; Communication<br />Media &amp; Communication (January)<br />Media &amp; Conflict Resolution<br />Molecular Microbiology<br />Nanoscience<br />Neuroscience &amp; Mental Health<br />Offshore Wind Energy<br />Pharmaceutical Analysis<br />Photonics<br />Political Economy<br />Political Research<br />Politics<br />Psotgraduate Diploma in Primary Education (PGDE)<br />Process Technology &amp; Management (Distance Learning)<br />Product Design<br />Professional Legal Practice<br />Project Management &amp; Innovation<br />Prosthetics &amp; Orthotics<br />Prosthetics &amp; Orthotics Rehabilitation Studies<br />Psychology with Specialisation in Business or Health<br />Public Policy<br />Public Policy (January)<br />Quantitative Finance<br />Quantum Technologies<br />Renewable Energy and Decqrbonisation Technologies<br />Research Methods in Psychology<br />Sattelite Data for Sustainable Development (January)<br />Ship and Offshore Structures<br />Ship and Offshore Structures (January)<br />Smart Grids with the Comillas Pontifical University, Madrid<br />Social Policy<br />Social Policy (Research Methods)<br />Social Work<br />Software Development<br />Sport Data Analytics<br />Subsea &amp; Pipeline Engineering<br />Subsea &amp; Pipeline Engineering (January)<br />Supply Chain &amp; Logistics Management<br />Supply Chain &amp; Logistics Management (January)<br />Supply Chain &amp; Procurement Management<br />Supply Chain &amp; Procurement Management (January)<br />Supply Chain &amp; Sustainability Management<br />Supply Chain &amp; Sustainability Management (January)<br />Sustainabilty<br />Sustainability &amp; Environmental Studies<br />Sustainability &amp; Environmental Studies (January)<br />Sustainability &amp; Environmental Studies (Online)<br />Sustainable Engineering: Chemical Processing<br />Sustainable Engineering: Chemical Processing (January)<br />Sustainable Engineering: Marine Technology<br />Sustainable Engineering: Marine Technology (January)<br />Sustainable Engineering: Offshore Renewable Energy<br />Sustainable Engineering: Offshore Renewable Energy (January)<br />Sustainable Engineering: Renewable Energy Systems &amp; the Environment<br />Sustainable Finance<br />Systems Engineering Management<br />Technical Ship Management<br />Technical Ship Management (January)<br />Technology Policy &amp; Management<br />TESOL Intercultural Communication<br />TESOL Intercultural Communication (January)<br />Tourism Marketing Management<br />Urban Design<br />Urban Policy &amp; Analysis<br />Wind Energy Systems<br />Work &amp; Organisational Psychology<br />\u201c<br />PhD, Mphil Accounting &amp; finance\u201d<br />PhD, MPhil Applied Linguistics<br />PhD, Mphil, MRes Architecture<br />MRes Biofluid mechanics<br />Mres, Mphil, PhD Biomedical engineering<br />PhD, MPhil Chemical &amp; process engineering<br />MPhil, PhD Chemistry<br />PhD, Mphil, MRes Civil &amp; environmental engineering<br />PhD, MPhil Computer &amp; information sciences<br />MPhil/ PhD Counselling<br />PhD, MPhil, MRes Creative writing<br />PhD Criminology<br />\u201c<br />PhD, MPhil, EngD, Industrial Doctorate Design, manufacturing &amp; engineering management\u201d<br />DInfSci Doctor of Information Science<br />Mphil, PhD Economics<br />Mphil, PhD Education<br />EdD Education<br />DEdPsy Educational Psychology<br />\u201c<br />MPhil, PhD, EngD &amp; Industrial Doctorate Electronic &amp; electrical engineering\u201d<br />PhD, Mphil, MRes English<br />PhD Entrepreneurship, Innovation &amp; Strategy<br />PhD Gender Studies<br />PhD, MPhil, MRes History<br />PhD History with Genealogical Studies<br />PhD, Mphil, MRes Journalism, Media &amp; Communication<br />PhD, MPhil Law<br />Mphil, PhD Management science<br />PhD, MPhil Marketing<br />PhD, Mphil, MRes Mathematics &amp; statistics<br />MPhil, PhD Mechanical &amp; aerospace engineering<br />PhD, Mphil, MRes Modern languages<br />PhD, MPhil, EngD, MRes Naval architecture, ocean &amp; marine engineering<br />PhD, MPhil Pharmacy &amp; biomedical sciences<br />PhD, MPhil, MRes Physical activity and health<br />PhD, MPhil, MRes Physics<br />PhD, MPhil Politics<br />Mphil, PhD, DEdPsy Psychology<br />PhD Public Health &amp; Health Policy<br />MRes Research Methodology for Business &amp; Management<br />PhD, MPhil Social work &amp; social policy<br />MRes Speech &amp; Language Sciences<br />PhD, MPhil Speech &amp; language therapy<br />PhD Translation Studies<br />PhD, MRes Work, employment &amp; organisation</p>\n\t\t\t<a href=\"https://www.strath.ac.uk/studywithus/postgraduatetaught/\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"https://www.facebook.com/UniversityOfStrathclyde/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://x.com/unistrathclyde\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.instagram.com/unistrathclyde/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.youtube.com/unistrathclyde\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.strath.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.strath.ac.uk/studywithus/internationalstudents/northlatinamerica/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.strath.ac.uk/studywithus/feesfunding/tuitionfees/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.strath.ac.uk/studywithus/scholarships/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.strath.ac.uk/professionalservices/finance/studentfinances/usdirectfederalloan/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://news.strath.ac.uk/p/2XTA-7TE/study-at-the-university-of-strathclyde-americas?pfredir=1\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.strath.ac.uk/studywithus/postgraduateresearchphdopportunities/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.strath.ac.uk/studywithus/accommodation/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.strath.ac.uk/professionalservices/careers/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.strath.ac.uk/studywithus/ourcampus/whatsoncampus/faithspiritualitysupport/clubssocietiesandgroups/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"https://google.com/\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"University of Strathclyde","post_link":"https://theukstudyexpert.com/universities/university-of-strathclyde/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Strathclyde\" width=\"300\" height=\"300\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/09/Untitled-design-82.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"3.0, 3.1, 3.2, 3.3+, Business Economics, Education, Engineering, Health Medicine, Humanities, Life Physical Sciences, Scotland, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"4","taxonomy=category":"Universities","taxonomy=post_tag":"3.0, 3.1, 3.2, 3.3+, Business Economics, Education, Engineering, Health Medicine, Humanities, Life Physical Sciences, Scotland, Social Science, Technology Computer Science","city_country":"Glasgow, Scotland"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":17625,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"University of Greenwich","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Greenwich\" width=\"300\" height=\"154\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/05/Untitled-design-79-e1723567215811-300x154.webp\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/greenwich/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">University of Greenwich</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                The University of Greenwich, London, is driven by a founding ethos of \u2018no limits\u2019. Our fundamental vision is to empower everyone to explore new possibilities, unbound by conventional wisdom and artificial boundaries. \r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"The University of Greenwich, London, is driven by a founding ethos of \u2018no limits\u2019. Our fundamental vision is to empower everyone to explore new possibilities, unbound by conventional wisdom and artificial boundaries. ","address":"Old Royal Naval College, Park Row, London SE10 9LS, UK","location":{"lat":"51.4829866","state":"England","country":"United Kingdom","lng":"-0.0063883","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/greenwich/","zoom":5,"extra_fields":{"post_excerpt":"The University of Greenwich, London, is driven by a founding ethos of \u2018no limits\u2019. Our fundamental vision is to empower everyone to explore new possibilities, unbound by conventional wisdom and artificial boundaries. ","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/Greenwich-campus-buildings.jpg\" alt=\"University of Greenwich campus\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/Postgraduate-students-walking-Greenwich.jpg\" alt=\"students walking\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/Stan-265-1.jpg\" alt=\"student and library\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/Smiling-student-Greenwich.jpg\" alt=\"student smiling\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/UoG_21Sep_001.jpg\" alt=\"UoG_21Sep_001\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/Students-sitting-on-steps-Greenwich.jpg\" alt=\"students sitting on steps\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact University of Greenwich\r\n</a>\r\n\r\n<strong>Location:</strong> Old Royal Naval College, Park Row, SE10 9LS\r\n\r\n<strong>Website:</strong> <a href=\"https://www.gre.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://gre.ac.uk/</a>\r\n<h3>Overview</h3>\r\nThe University of Greenwich, London, is driven by a founding ethos of \u2018no limits\u2019. Our fundamental vision is to empower everyone to explore new possibilities, unbound by conventional wisdom and artificial boundaries. Voted by StudentCrowd as the Number 1 University in London and by WhatUni Student Choice as the Number 1 University in London for international students, the University of Greenwich is a lively and diverse community of people united by their passion for learning. As a multi-faculty university, we offer a range of courses, designed in conjunction with business, industry and technology to prepare you for the next stage of your career. We have a comprehensive range of support services for all our students, including scholarships and a Wellbeing Hub, and we\u2019re also one of the few London universities that has everything you need in one place. Teaching, social, sports and living spaces are all on campus or nearby.\r\n\r\n<strong>Population: </strong>30,000\r\n\r\n<strong>Campus Type: </strong>Urban\r\n<h3>Quick Facts</h3>\r\n<ul data-rte-list=\"default\">\r\n \t<li>22,000+ international students from over 100 countries</li>\r\n \t<li>Ranked No. 1 the best UK university by StudentCrowd Awards 2023</li>\r\n \t<li>Awarded Gold in the TEF 2023 awards</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=r5TBd6YrGXohttps://www.youtube.com/watch?v=GJq1J28mqKQhttps://www.youtube.com/watch?v=ZsBJPaHnESY\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nWe are test optional for our Undergraduate courses. For standard entry, you will need to have the following:\r\n\r\nHigh School Diploma with a minimum GPA 3.2 or GED with a minimum grade of 175\r\n\r\nFor students with a GPA 2.8 or GED of 165, you will also need ONE of the following:\r\n<ul>\r\n \t<li>ACT - Grade 22 or above</li>\r\n \t<li>AP - Grade 3 or above in 2 advanced placement tests</li>\r\n \t<li>SAT - 1050 in SAT with minimum of 500 in each section (Post-March 2016) or 1650 (pre-March 2016)</li>\r\n</ul>\r\nIB - modules with a minimum points of 18\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n\r\nAgriculture (Final Year Entry) (Hadlow),BSc Hons\r\nAccounting and Business Analytics, BA Hons\r\nAccounting and Finance (Extended), BA Hons\r\nAccounting and Finance, BA Hons\r\nAccounting and Finance, BA Hons (Year 2 &amp; 3 Direct Entry)\r\nAdult Nursing (Medway), BSc Hons\r\nAdult Nursing, BSc Hons\r\nAdult Nursing, BSc Hons (Degree Apprenticeship)\r\nAnimal Management (Final Year Entry) (Hadlow), BSc Hons\r\nAnimation, BA Hons\r\nApplied Animal Behaviour and Welfare (Final Year Entry) (QA Only), BSc (Plumpton)\r\nApplied Animal Behavioural Science (Final Year Entry) (Hadlow), BSc Hons\r\nApplied Biomedical Science, BSc Hons\r\nAquaculture and Fisheries Management (Final Year Entry) (Hadlow), BSc Hons\r\nArchitecture, BA Hons\r\nBiology (Extended), BSc Hons\r\nBiology, BSc Hons\r\nBiology, MBiol\r\nBiomedical Science (Extended), BSc Hons\r\nBiomedical Science, BSc Hons\r\nBuilding Studies, HNC (London South East Colleges)\r\nBuilding Studies, HND (QA Only) (London South East Colleges)\r\nBuilding Surveying, HNC (London South East Colleges)\r\nBuilding Surveying, HND (QA Only) (London South East Colleges)\r\nBusiness Computing, BSc Hons\r\nBusiness Economics, BA Hons\r\nBusiness Entrepreneurship and Innovation, BA Hons\r\nBusiness Logistics and Supply Chain Management (Year 2 &amp; 3 Direct Entry), BA Hons\r\nBusiness Logistics and Supply Chain Management, BA Hons\r\nBusiness Management (Extended), BA Hons\r\nBusiness Management (Year 2 &amp; 3 Entry), BA Hons\r\nBusiness Management and Leadership, BA Hons\r\nBusiness Management, BA Hons\r\nBusiness Psychology, BSc Hons\r\nBusiness Studies (Year 2 &amp; 3 Direct Entry), BA Hons\r\nBusiness Studies, BA Hons\r\nBusiness with Accounting (Year 3 Direct Entry), BA Hons\r\nBusiness with Finance (Year 2 &amp; 3 Direct Entry), BA Hons\r\nBusiness with Finance, BA Hons\r\nBusiness with Marketing (Year 2 &amp; 3 Direct Entry), BA Hons\r\nBusiness with Marketing, BA Hons\r\nCertificate of Higher Education in Sports Coaching, CertHE\r\nChemical Engineering (Extended), BEng Hons\r\nChemical Engineering with Industrial Practice, BEng Hons\r\nChemical Engineering, BEng Hons\r\nChemical Engineering, MEng\r\nChemistry (Extended), BSc Hons\r\nChemistry, BSc Hons\r\nChemistry, BSc Hons (Degree Apprenticeship)\r\nChildren\u2019s Nursing, BSc Hons\r\nChildren\u2019s Nursing, BSc Hons (Degree Apprenticeship)\r\nCivil Engineering (Extended), BEng Hons\r\nCivil Engineering (Royal School of Military Engineering), BEng (Hons)\r\nCivil Engineering, BEng Hons\r\nCivil Engineering, MEng\r\nComputer Engineering (Extended), BEng Hons\r\nComputer Engineering, BEng Hons\r\nComputer Engineering, MEng\r\nComputer Science (Artificial Intelligence), BSc Hons\r\nComputer Science (Cyber Security), BSc Hons\r\nComputer Science (Data Science), BSc Hons\r\nComputer Science (Games), BSc Hons\r\nComputer Science (Networking), BSc Hons\r\nComputer Science, BSc Hons\r\nComputing (Artificial Intelligence), BSc Hons\r\nComputing (Information Systems), BSc Hons\r\nComputing (Network Systems), BSc Hons\r\nComputing for Emerging Technologies, BSc Hons\r\nComputing, BSc Hons\r\nComputing, BSc Hons (Extended)\r\nConstruction Design and Build Technician, CertHE\r\nConstruction Management, BSc Hons\r\nConstruction Management, BSc Hons (Degree Apprenticeship)\r\nConstruction Management, HNC (London South East Colleges)\r\nConstruction Site Supervisor, CertHE\r\nCreative Advertising and Art Direction, BA Hons\r\nCreative Writing and English Literature, BA Hons\r\nCreative Writing, BA Hons\r\nCriminology and Criminal Justice, BA Hons\r\nCriminology and Criminal Psychology (Extended), BSc Hons\r\nCriminology and Criminal Psychology, BSc Hons\r\nCyber Security and Digital Forensics, BSc Hons\r\nCybernetics (Extended), BEng Hons\r\nCybernetics, BEng Hons\r\nCybernetics, MEng\r\nData Science, BSc Hons\r\nDigital Marketing and Advertising, BA Hons\r\nDigital and Technology Solutions, BSc Hons (Degree Apprenticeship)\r\nDrama and English Literature with International Study, BA Hons\r\nDrama and English Literature, BA Hons\r\nDrama with International Study, BA Hons\r\nDrama, BA Hons\r\nEarly Years, BA Hons\r\nEarly Years, BA Hons (Top-up)\r\nEconomics (Year 2 &amp; 3 Direct Entry), BSc Hons\r\nEconomics, BSc Hons\r\nEducation Studies (Final Year Entry) (North Kent College \u2013 Tonbridge)\r\nEducation Studies, BA Hons (Top up) (NESCOT)\r\nElectrical Engineering (Royal School of Military Engineering), BEng (Hons)\r\nElectrical and Electronic Engineering (Extended), BEng Hons\r\nElectrical and Electronic Engineering Technology, BEng Hons\r\nElectrical and Electronic Engineering, BEng Hons\r\nElectrical and Electronic Engineering, MEng\r\nEmbedded Electronic Systems Design and Development, BEng Hons\r\nEmbedded Electronic Systems Design and Development, BEng Hons (Degree Apprenticeship)\r\nEngineering Management (Extended), BEng Hons\r\nEngineering Management, BEng Hons\r\nEngineering Manufacturing Technician, CertHE\r\nEngineering, Design and Innovation (Extended), BEng Hons\r\nEngineering, Design and Innovation, BEng Hons\r\nEnglish Language and Literature, BA Hons\r\nEnglish Language and TESOL, BA Hons\r\nEnglish Literature with Creative Writing, BA Hons\r\nEnglish Literature, BA Hons\r\nEquine Training and Management (Final Year Entry) (Hadlow), BSc Hons\r\nEvents Management and Innovation, BA Hons\r\nFilm Studies, BA Hons\r\nFilm and Television Production, BA Hons\r\nFinance and Investment Banking, BSc Hons\r\nFinance and Investment Banking, BSc Hons (Year 2 &amp; 3 Direct Entry)\r\nFinancial Mathematics, BSc Hons\r\nFood Science &amp; Nutrition, BSc Hons\r\nFood and Drink Engineer, DipHE\r\nForensic Science (Extended), BSc Hons\r\nForensic Science with Criminology (Extended), BSc Hons\r\nForensic Science with Criminology and Industrial Placement, BSc Hons\r\nForensic Science with Criminology, BSc Hons\r\nForensic Science with Industrial Placement, BSc Hons\r\nForensic Science, BSc Hons\r\nForensic Toxicology, BSc Hons\r\nForensic and Digital Investigation with Industrial Placement, BSc Hons\r\nForensic and Digital Investigation, BSc Hons\r\nFurther Education and Skill Sector,Prof Cert Ed (FE) (QA Only) (NESCOT)\r\nGames Development, BSc Hons\r\nGraduate Diploma Enhanced Clinical Practice (Apprenticeship)\r\nGraphic and Digital Design, BA Hons\r\nGraphic and Digital Design, HND\r\nHealth and Social Care, BA Hons (Top-up)\r\nHistory and English, BA Hons\r\nHistory and Politics, BA Hons\r\nHistory and Sociology, BA Hons\r\nHistory, BA Hons\r\nHorticulture (Commercial) (Final Year Entry) (Hadlow), BSc Hons\r\nHospitality Management (Year 2 &amp; 3 Direct Entry), BA Hons\r\nHospitality Management, BA Hons\r\nHuman Nutrition &amp; Health (Extended), BSc Hons\r\nHuman Nutrition &amp; Health, BSc Hons\r\nHuman Resource Management, BA Hons\r\nInternational Business with Language, BA Hons\r\nInternational Business, BA Hons\r\nInternational Wine Business (QA only), BA (Plumpton College)\r\nLandscape Architecture, BA Hons\r\nLanguages and International Relations, BA Hons\r\nLaw (Extended), LLB Hons\r\nLaw Senior Status, LLB Hons\r\nLaw in Practice, LLB Hons\r\nLaw with Criminology, LLB Hons\r\nLaw, LLB Hons\r\nLearning Disabilities Nursing, BSc Hons\r\nLearning Disabilities Nursing, BSc Hons (Degree Apprenticeship)\r\nMarketing and Brand Management, BA Hons\r\nMathematics and Computer Science, BSc Hons\r\nMathematics, BSc Hons\r\nMechanical Engineering (Extended), BEng Hons\r\nMechanical Engineering Technology, BEng Hons\r\nMechanical Engineering, BEng Hons\r\nMechanical Engineering, MEng\r\nMechanical and Building Services Engineering (Royal School of Military Engineering), BEng (Hons)\r\nMedia and Communications, BA Hons\r\nMental Health Nursing, BSc Hons\r\nMental Health Nursing, BSc Hons (Degree Apprenticeship)\r\nMidwifery (Avery Hill), BSc Hons\r\nMidwifery (Degree Apprenticeship)\r\nMidwifery (Medway), BSc Hons\r\nMusic and Sound Production, BA Hons\r\nOccupational Safety, Health and Environment, BSc Hons (Top-up)\r\nOperating Department Practitioner, BSc Hons\r\nOperating Department Practitioner, BSc Hons (Degree Apprenticeship)\r\nParamedic Science, BSc Hons\r\nPharmaceutical Sciences (Extended), BSc Hons\r\nPharmaceutical Sciences, BSc Hons\r\nPharmaceutical Sciences, BSc Hons (Degree Apprenticeship)\r\nPharmacy, MPharm\r\nPhysical Education and Sport, BA Hons\r\nPhysiotherapy, BSc Hons\r\nPolitics and International Relations, BA Hons\r\nPrimary Education Studies (2-Year Accelerated Degree), BA Hons\r\nPrimary Education with QTS (5-11), BA Hons\r\nProfessional Certificate in Education (Further Education &amp; Skills) (NESCOT) (QA)\r\nProfessional Certificate in Education (Further Education and Training)\r\nProfessional Dance and Musical Theatre, BA Hons\r\nPsychology (Extended), BSc Hons\r\nPsychology with Counselling, BSc Hons\r\nPsychology, BSc Hons\r\nPublic Health (Extended), BSc Hons\r\nPublic Health, BSc Hons\r\nQuantity Surveying, BSc Hons\r\nQuantity Surveying, BSc Hons (Degree Apprenticeship)\r\nQuantity Surveying, HNC (London South East Colleges)\r\nQuantity Surveying, HND (QA Only) (London South East Colleges)\r\nRural Land and Business Management (QA only), BSc (Plumpton College)\r\nSocial Work, BA Hons\r\nSociology and Criminology, BSc Hons\r\nSociology and Psychology, BSc Hons\r\nSociology, BA Hons\r\nSoftware Engineering, BEng Hons\r\nSpecialist Community Public Health Nursing (Health Visiting and School Nursing), BSc Hons (Top-up)\r\nSpecialist Practitioner (District Nursing), BSc Hons (Top up)\r\nSpeech and Language Therapy, BSc Hons\r\nSport and Exercise Science, BSc\r\nStatistics and Data Analytics, BSc Hons\r\nStudy Abroad, LLB Hons\r\nSustainable Agriculture (QA only), BSc (Plumpton College)\r\nTourism Management with Language, BA Hons\r\nTourism Management, BA Hons\r\nViticulture and Oenology (QA only), BSc (Plumpton College)\r\n\r\n<a href=\"https://www.gre.ac.uk/undergraduate-courses/a-z\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nFor entry to our Master's programmes, you will need to have met the following:\r\n<ul>\r\n \t<li>Bachelor degree with a minimum GPA 2.8 for UK 2:2<strong>OR</strong></li>\r\n \t<li>Bachelor degree with a minimum GPA 3.0 for UK 2:1</li>\r\n</ul>\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n\r\nData Science and its Applications (Medway), MSc\r\nAccounting and Finance, MPhil/PhD\r\nAccounting and Finance, MSc\r\nAdvanced Chemical Engineering with Industrial Practice, MSc\r\nAdvanced Chemical Engineering, MSc\r\nAdvanced Clinical Practice, MSc\r\nAdvanced Clinical Practitioner, MSc (Degree Apprenticeship)\r\nAgriculture for Sustainable Development, MSc\r\nApplied Artificial Intelligence for Engineering, MSc\r\nApplied Criminology, MA\r\nApplied Food Safety and Quality Management with Industrial Practice, MSc\r\nApplied Food Safety and Quality Management, PGDip/MSc\r\nApplied Linguistics, MA\r\nArchitectural Practice, PGDip (ARB/RIBA Part 3 Exemption)\r\nArchitecture Part 2, MArch\r\nArchitecture, Landscape and Urbanism, MSc\r\nAward of Institutional Credit in Learning and Teaching in Higher Education\r\nBig Data and Business Intelligence, MSc\r\nBiomedical Science, MSc/PGDip/PGCert\r\nBiotechnology, MSc\r\nBuilt Environment, MPhil/PhD\r\nBusiness Analytics, MSc\r\nBusiness, MPhil/PhD\r\nChild and Adolescent Psychology, MSc\r\nCivil Engineering with Industrial Practice, MSc\r\nCivil Engineering, MSc\r\nComputer Forensics and Cyber Security, MSc\r\nComputer Science (Network Engineering), MSc\r\nComputer Science, MPhil/PhD\r\nComputer Science, MSc\r\nComputing and Information Systems, MSc\r\nComputing and Mathematical Sciences, MSc by Research\r\nConstruction Management and Economics, MSc\r\nConstruction Project Management, MSc\r\nCreative Writing, MA\r\nCriminology and Criminal Psychology, MSc\r\nCriminology, Gender and Sexualities, MSc\r\nData Science (FinTech), MSc\r\nData Science and its Applications, MSc\r\nData Science, MSc\r\nDesign, MA\r\nDevelopment Studies \u2013 Research, MPhil/PhD\r\nDigital Arts, MA\r\nDigital Marketing Management, MSc\r\nDoctorate in Education, EdD\r\nEconomics, MPhil/PhD\r\nEconomics, MSc\r\nEducation and Training, MPhil/PhD\r\nEducation, MA\r\nEducation, MPhil/PhD\r\nElectrical Power Engineering with Industrial Practice, MSc\r\nElectrical Power Engineering, MSc\r\nElectrical and Electronic Engineering with Industrial Practice, MSc\r\nElectrical and Electronic Engineering, MSc\r\nEngineering \u2013 Research, MPhil/PhD\r\nEngineering Management with Industrial Practice, MSc\r\nEngineering Management, MSc\r\nEngineering, MSc by Research\r\nEnglish Literature, MA\r\nEnhanced Professional Practice, PGDip\r\nExecutive Master of Business Administration, MBA\r\nFacilities Management, MSc\r\nFilm Production, MA\r\nFinance and Investment, MSc\r\nFinance, MBA\r\nFinancial Management and Risk, MSc\r\nFintech and Finance, MSc\r\nFood Innovation with Industrial Practice, MSc\r\nFood Innovation, MSc\r\nFood Safety and Quality Management e-learning, PGCert/PGDip/MSc\r\nForensic Psychology, MSc\r\nFormulation Science, MSc\r\nGeneral Pharmacy Practice, PGCert/PGDip/MSc\r\nGlobal Environmental Change, MSc\r\nGlobal Health Management, MSc\r\nGlobal Public Health MSc\r\nGlobal Shipping Management, MSc\r\nGlobal Sustainable Development, MSc\r\nHaematology, MSc/PGDip/PGCert\r\nHealth Sciences, MPhil/PhD\r\nHealthcare Management, MSc/PGDip/PGCert\r\nHealthcare Practice, MA\r\nHealthcare Quality Management, MSc/PGDip/PGCert\r\nHigher Education, PGCert\r\nHuman Resource Management, MA\r\nHuman Resources and Organisational Behaviour, MPhil/PhD\r\nHuman Sciences, MPhil/PhD\r\nIndependent/Supplementary Prescribing, PGCert\r\nInternational &amp; Commercial Law, LLM\r\nInternational Banking and Finance, MSc\r\nInternational Business, MA\r\nInternational Business, MA (Dual Award, Greenwich and New Zealand)\r\nInternational Events Management, MA\r\nInternational Postgraduate Certificate in Education (Online)\r\nInternational Relations, MA\r\nInternational Tourism and Hospitality Management, MA\r\nInterprofessional Healthcare Simulation, MSc\r\nLandscape Architecture, MA\r\nLandscape Architecture, MLA\r\nLaw, Regulation and the International Financial System, MSc\r\nLogistics and Supply Chain Management, MA\r\nManagement of Business Information Technology, MSc\r\nMarketing Management, MA\r\nMarketing Management, MBA\r\nMathematical Sciences, MPhil/PhD\r\nMechanical and Manufacturing Engineering with Industrial Practice, MSc\r\nMechanical and Manufacturing Engineering, MSc\r\nMedia and Creative Cultures, MA\r\nMedicines Optimisation, PGCert/PGDip/MSc\r\nMusic and Sound Design, MA\r\nNatural Resources, MSc (by Research)\r\nNursing (Adult Nursing), MSc\r\nNursing (Children\u2019s Nursing), MSc\r\nNursing (Learning Disabilities Nursing), MSc\r\nNursing (Mental Health Nursing), MSc\r\nOccupational Hygiene, MSc\r\nOccupational Psychology, MSc\r\nPharmaceutical Science, MSc/PGDip\r\nPharmaceutical Sciences with Industrial Practice, MSc\r\nPost Graduate Certificate in Education (Further Education and Training)\r\nPostgraduate Certificate in Education (Further Education &amp; Skills) (NESCOT) (QA)\r\nPrimary Education (3-11) (Provider-led School-based) with QTS, PGCE\r\nPrimary Education (3-11) (Provider-led University-based) with QTS, PGCE\r\nProduct Design Engineering, MSc\r\nProfessional Graduate Certificate in Education (Further Education &amp; Skills) (NESCOT) (QA)\r\nProfessional Graduate Certificate in Education (Further Education and Training)\r\nPsychology, MSc (Conversion Degree)\r\nReal Estate Development and Investment, MSc\r\nReal Estate, MSc\r\nSafety, Health and Environment, MSc\r\nScience \u2013 Research, MPhil/PhD\r\nScience, MSc by Research\r\nSecondary PGCE (11-19) (Provider-led School-based) with QTS\r\nSecondary PGCE with QTS (11-19) (Provider-led) (Mathematics)\r\nSecondary PGCE with QTS (11-19) (Provider-led) (Physical Education)\r\nSecondary PGCE with QTS (11-19) (Provider-led) (Science with Biology)\r\nSecondary PGCE with QTS (11-19) (Provider-led) (Science with Chemistry)\r\nSecondary PGCE with QTS (11-19) (Provider-led) (Science with Physics)\r\nSenior Leader Apprenticeship\r\nSocial Work, PGDip\r\nSocial Work, PGDip/MA\r\nSpecial Educational Needs: Leading Effective and Inclusive Practice (National Award for Special Educational Needs Coordination), PGCert\r\nSpecialist Community Public Health Nursing (Health Visiting and School Nursing), PGDip\r\nSpecialist Practitioner (District Nursing), PGDip\r\nSport and Exercise Psychology, MSc\r\nStrategic Marketing, MA (Dual Award)\r\nStrength and Conditioning, MSc\r\nSustainable Building Design and Engineering, MSc\r\nTherapeutic Counselling, MSc\r\nViticulture and Oenology (QA only), MSc (Plumpton College)\r\nWater, Waste and Environmental Engineering with Industrial Practice, MSc\r\nWater, Waste and Environmental Engineering, MSc\r\nWeb Design and Content Planning, MA\r\n\r\n<a href=\"https://www.gre.ac.uk/postgraduate-courses\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/uniofgreenwich/\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://x.com/UniofGreenwich?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor\" target=\"_blank\" rel=\"noopener\">\r\nX-twitter\r\n</a>\r\n<a href=\"https://www.instagram.com/uniofgreenwich/?hl=en\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/@UniversityGreenwich\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.gre.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/international/countries/usa\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/international\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/bursaries/international-scholarships-award\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/finance/funding-your-studies/loans/federal-loans-for-usa-students\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.gre.ac.uk/events\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/research\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/accommodation\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.gre.ac.uk/careers\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.greenwichsu.co.uk/\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://www.gre.ac.uk/study/apply/international\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"University of Greenwich","post_link":"https://theukstudyexpert.com/universities/greenwich/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Greenwich\" width=\"300\" height=\"154\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/05/Untitled-design-79-e1723567215811-300x154.webp\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"5","taxonomy=category":"Universities","taxonomy=post_tag":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"London, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":16826,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Edinburgh Napier University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Edinburgh Napier\" width=\"300\" height=\"145\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/Untitled-design-80-e1723220736832-300x145.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/edinburgh-napier-university/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Edinburgh Napier University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                We have more than 300 undergraduate and postgraduate courses and nearly 20,000 students from over 140 countries studying on campus in Edinburgh, online and at partner universities worldwide.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"We have more than 300 undergraduate and postgraduate courses and nearly 20,000 students from over 140 countries studying on campus in Edinburgh, online and at partner universities worldwide.","address":"9 Sighthill Ct, Edinburgh EH11 4BN, UK","location":{"lat":"55.9248537","state":"Scotland","country":"United Kingdom","lng":"-3.2887076","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/edinburgh-napier-university/","zoom":5,"extra_fields":{"post_excerpt":"We have more than 300 undergraduate and postgraduate courses and nearly 20,000 students from over 140 countries studying on campus in Edinburgh, online and at partner universities worldwide.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/Edinburgh-napier.png\" alt=\"Edinburgh Napier\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/b25lY21zOjMzMzE0MGUwLWY5ZTItNGU3OS1hZmMyLWNiZjBmMDBkZTUzZDo0MGNiMDkzNS0zMzg0LTQ5NTQtYjRhNS0wMTBkOWQwNzZhY2E.jpg\" alt=\"Edinburgh Napier\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/24288_400x400.jpg\" alt=\"Edinburgh Napier\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/pexels-harry-shum-17627821-18391675.jpg\" alt=\"Edinburgh Napier\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/2209603-1.jpg\" alt=\"Edinburgh Napier\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/61dc07e4a4f22-1.jpg\" alt=\"Edinburgh Napier\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact Edinburgh Napier University\r\n</a>\r\n\r\n<strong>Location:</strong> 9 Sighthill Ct., Edinburgh, Scotland, EH11 4BN, United Kingdom\r\n\r\n<strong>Website:</strong> <a href=\"https://www.napier.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://napier.ac.uk/</a>\r\n<h3>Overview</h3>\r\nA journey you'll remember!\r\n\r\nIt starts with travelling to a world-class university and goes wherever you want to take it.\r\n\r\nWe are Edinburgh Napier University, the #1 modern university in Scotland (Times Higher Education World University Rankings 2023), the #1 university in Edinburgh for student satisfaction (NSS 2020, 2021, 2022 &amp; 2023), a top 10 UK modern university (Times/Sunday Times Good University Guide 2023), and the top Scottish modern university for research power and impact (Research Excellence Framework 2021).\r\n\r\nWe pride ourselves on being the home of difference makers\u2014an enterprising and innovative community, renowned internationally, with an unrivalled student learning experience.\r\n\r\nWith more than 300 undergraduate and postgraduate courses and nearly 20,000 students from over 140 countries studying on campus in Edinburgh, online and at partner universities worldwide, we deliver meaningful, difference-making education and research for a rapidly changing world.\r\n\r\nAt Edinburgh Napier University, we\u2019re bold, ambitious and innovative. With strong industry links, we deliver a truly hands-on learning experience to ensure you\u2019re equipped with the skills and expertise to advance your knowledge and career.\r\nStart your journey today.\r\n\r\n<strong>Population: </strong>22,000\r\n\r\n<strong>Campus Type: </strong>Urban\r\n<h3>Quick Facts</h3>\r\n<ul data-rte-list=\"default\">\r\n \t<li>Top Scottish modern university for both research power and research impact</li>\r\n \t<li>Number 1 modern university in Scotland - THE World University Rankings 2023</li>\r\n \t<li>Number 1 university in Edinburgh for student satisfaction - National Student Survey 2023</li>\r\n \t<li>95% of our graduates are in work or further study 15 months after graduation</li>\r\n \t<li>Over 4,000 international students on campus from more than 140 countries</li>\r\n \t<li>Nearly 700 start-ups have been supported by our in-house business incubator</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://youtu.be/IVl_fulWWJohttps://youtu.be/TvZueMOujJE?si=pxWzhZFsJVN90WEXhttps://www.youtube.com/watch?v=4YubvDz9fAo\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nIn Scotland, undergraduate courses (called honours degrees) are designed to include four years of study, which is unique in the UK. Honours degrees offer enhanced flexibility and academic breadth.\r\n\r\nYou are eligible to apply if you received your High School Graduation Diploma with a GPA of 2.8 or above with one of the following:\r\n<ul>\r\n \t<li>SAT score of 1000 or higher with a minimum of 500 in each component</li>\r\n \t<li>ACT score of 24 or higher</li>\r\n \t<li>3 related Advanced Placement tests (AP's) with a grade of 4 or higher</li>\r\n</ul>\r\nIf you're applying with the GED, you are eligible if you have a pass in each of the 4 sections with a minimum score of 145/200 and an overall score of 580/800. You would need one of the 3 requirements above in addition.\r\n\r\nIf you're applying with an International Baccalaureate (IB), you are eligible if you have a minimum score of 26-30 in relevant subjects.\r\n\r\nIf you have attended a community college or would like to transfer to Edinburgh Napier, you may be considered for advanced entry into year 2 or 3 of a relevant degree course. Contact us to find out if you're eligible.\r\n\r\nEdinburgh Napier SAT institution code: 7894\r\n\r\nEdinburgh Napier ACT institution code: 3004\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n\r\nBSc (Hons) Animal &amp; Conservation Biology\r\nBSc (Hons) Applied Microbiology\r\nBSc (Hons) Biological Sciences\r\nBSc (Hons) Biomedical Science\r\nBSc (Hons) Marine &amp; Freshwater Biology\r\nBA (Hons) Business Management\r\nBA (Hons) Business Management with Entrepreneurship\r\nBA (Hons) Business Management with Human Resource Management\r\nBA (Hons) Business Management with Marketing\r\nBSc (Hons) Informatics for Business\r\nBA (Hons) International Business Management\r\nBSc (Hons) Architectural Technology\r\nBSc (Hons) Building Surveying\r\nBSc (Hons) Quantity Surveying\r\nBSc (Hons) Real Estate Surveying\r\nBEng (Hons) Computing\r\nBSc (Hons) Computer Science\r\nBSc (Hons) Computer Science (Artificial Intelligence)\r\nBEng (Hons) Computer Systems &amp; Networks\r\nBEng (Hons) Cybersecurity &amp; Forensics\r\nBSc (Hons) Data Science\r\nBSc (Hons) Digital Media &amp; Interaction Design\r\nBSc (Hons) Digital Media &amp; Interaction Design Global\r\nBSc (Hons) Games Development\r\nBSc (Hons) Informatics for Business\r\nBEng (Hons) Software Engineering\r\nMEng Software Engineering\r\nBSc (Hons) Sound Design\r\nBSc (Hons) User Experience (UX) Design\r\nBSc (Hons) Web Design &amp; Development\r\nBA (Hons) Criminology\r\nBSc (Hons) Policing &amp; Criminology\r\nBSc (Hons) Psychology\r\nBA (Hons) Psychology Sociology\r\nBA (Hons) Social Sciences\r\nBSc (Hons) Digital Media &amp; Interaction Design\r\nBDes (Hons) Graphic Design\r\nBDes (Hons) Interior &amp; Spatial Design\r\nBA (Hons) Photography\r\nBDes (Hons) Product Design\r\nBSc (Hons) Sound Design\r\nBSc (Hons) User Experience (UX) Design\r\nBEng (Hons) Civil Engineering\r\nMEng Civil Engineering\r\nMEng Civil &amp; Transportation Engineering\r\nBEng (Hons) Electrical &amp; Electronic Engineering\r\nMEng Electrical &amp; Electronic Engineering\r\nBEng (Hons) Energy &amp; Environmental Engineering\r\nBEng (Hons) Mechanical Engineering\r\nMEng Mechanical Engineering\r\nBSc (Hons) Digital Media &amp; Interaction Design\r\nBSc (Hons) Digital Media &amp; Interaction Design Global\r\nBA (Hons) English &amp; Film\r\nBA (Hons) Film\r\nBA (Hons) Journalism\r\nBA (Hons) Marketing with Digital Media\r\nBA (Hons) Mass Communications\r\nBA (Hons) Mass Communications, Advertising and Public Relations\r\nBA (Hons) Photography\r\nBA (Hons) Acting &amp; English\r\nBA (Hons) English\r\nBA (Hons) English &amp; Film\r\nLLB/LLB (Hons) Law\r\nBA (Hons) Business Management with Marketing\r\nBA (Hons) Marketing Management\r\nBA (Hons) Marketing with Digital Media\r\nBA (Hons) Music\r\nBSc (Hons) Football Coaching, Performance and Development\r\nBSc (Hons) Physical Activity &amp; Health\r\nBSc (Hons) Sport &amp; Exercise Science\r\nBSc (Hons) Sports Coaching\r\nBA (Hons) International Festival &amp; Event Management\r\nBA (Hons) International Hospitality Management\r\nBA (Hons) International Hospitality Management and Festival &amp; Events\r\nBA (Hons) International Tourism Management\r\nBA (Hons) International Tourism &amp; Airline Management\r\n\r\n<a href=\"https://www.napier.ac.uk/study-with-us/undergraduate\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nOur taught postgraduate degrees are one year in duration.\r\n\r\nYou are eligible to apply if you completed a bachelor degree with a minimum GPA of 2.7 or above.\r\n\r\nNo GRE/GMAT test scores are required.\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n<a href=\"https://www.napier.ac.uk/study-with-us/postgraduate\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/EdinburghNapierUniversity/\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://x.com/edinburghnapier?lang=en\" target=\"_blank\" rel=\"noopener\">\r\nX-twitter\r\n</a>\r\n<a href=\"https://www.instagram.com/edinburghnapier/?hl=en\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/@EdinburghNapierUni\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.napier.ac.uk\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/study-with-us/international-students/your-country/americas/usa\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/courses\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/study-with-us/bursaries\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/study-with-us/international-students/your-country/americas/usa/fees-and-scholarships/federal-aid\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.napier.ac.uk/about-us/events\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/research-and-innovation\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.napier.ac.uk/study-with-us/accommodation\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://staff.napier.ac.uk/services/sas/student_development/Careers/Pages/Careers-Support-for-Students.aspx\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.napierstudents.com/organisation/societies/\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://www.napier.ac.uk/study-with-us/international-students/how-to-apply\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"Edinburgh Napier University","post_link":"https://theukstudyexpert.com/universities/edinburgh-napier-university/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Edinburgh Napier\" width=\"300\" height=\"145\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/08/Untitled-design-80-e1723220736832-300x145.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"Business Economics, Engineering, Health Medicine, Life Physical Sciences, Scotland, Technology Computer Science","%_custom_priority_meta_key%":"","taxonomy=category":"Universities","taxonomy=post_tag":"Business Economics, Engineering, Health Medicine, Life Physical Sciences, Scotland, Technology Computer Science","city_country":"Edinburgh, Scotland"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":16627,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Southampton Solent University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Southampton Solent University\" width=\"300\" height=\"300\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/southampton-solent-logo-full-color-rgb-900px-w-72ppi-1-1-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/southampton-solent-university/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Southampton Solent University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Southampton Solent University is all about creating opportunities: for its students, for its staff, for its partners. It offers expertise and experiences you couldn\u2019t get anywhere else.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Southampton Solent University is all about creating opportunities: for its students, for its staff, for its partners. It offers expertise and experiences you couldn\u2019t get anywhere else.","address":"Above Bar St, Southampton SO14 7DW, UK","location":{"lat":"50.9094493","state":"England","country":"United Kingdom","lng":"-1.4029522","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/southampton-solent-university/","zoom":5,"extra_fields":{"post_excerpt":"Southampton Solent University is all about creating opportunities: for its students, for its staff, for its partners. It offers expertise and experiences you couldn\u2019t get anywhere else.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/Court-room-1.jpg\" alt=\"Court room 1\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/City-centre-campus-around-parks_1500x1500.jpg\" alt=\"City centre campus around parks_1500x1500\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/Spark-for-Meritza-6.jpg\" alt=\"Spark for Meritza 6\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/2019JunJulyAugCaseStudiesMultipleImages_1156w_518h-a.jpg\" alt=\"2019JunJulyAugCaseStudiesMultipleImages_1156w_518h-a\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/East-Park-cafe_1500x1500-007.jpg\" alt=\"East Park cafe_1500x1500 (007)\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/Spark-for-Meritza-3.jpg\" alt=\"Spark for Meritza 3\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact Southampton Solent University\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> East Park Terrace, Southampton SO14 0YN</p><p><strong>Website:</strong> <a href=\"http://solent.ac.uk\" target=\"_blank\" rel=\"noopener\">http://solent.ac.uk</a></p><p>Southampton Solent University is all about creating opportunities: for its students, for its staff, for its partners. It offers expertise and experiences you couldn\u2019t get anywhere else, opening doors and making introductions. We\u2019re focused on the practical side of higher education \u2013 giving our students the connections, experience, and confidence to turn their newfound knowledge into a career with real, meaningful impact. Whoever you are, whatever your goals, we want to help you make your mark.</p>\n<p></p>\n<p>If there's one thing our 160-year history has taught us, it's that employers are expecting more than ever from modern graduates. Our job is to ensure you leave your course ready to exceed those expectations - equipping you with the hands-on skills and workplace confidence you'll need to succeed.<br><br></p>\n<p></p>\n<p>Employability sits at the heart of everything we do. Our curriculums, created in collaboration with industry employers, guarantee that the skills and knowledge you gain have genuine market value. Our teaching teams extend this value, injecting their first-hand experience into every aspect of your degree. Everyone learns differently. If at any point during your studies you feel you may benefit from extra support, you'll be able to access it. <br><br></p>\n<p></p>\n<p>This isn't limited to academic support either. Whether you want help setting up your own business, are worried about your finances or simply want help with looking for part-time work, our support services will be there for you. International students make up around 15 per cent of the student community here at Solent. We welcome international students from all over the world - giving our city-centre campus and our classrooms a diverse, multicultural feel. <br><br></p>\n<p></p>\n<p><strong>Population: </strong>10,510</p>\n<p><strong>Campus Type: </strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li>Teaching Excellence Framework (TEF), Triple Gold Ratings</li><li>15th in the sector for graduate start-ups (HESA 2023)</li></ul><ul data-rte-list=\"default\"><li>37th for Teaching Quality in the Times Good University Guide 2023</li></ul><ul data-rte-list=\"default\"><li>100m investment in our campus and state-of-the-art facilities</li></ul><ul data-rte-list=\"default\"><li>Delivering the Government\u2019s Help to Grow Covid-recovery business management programme</li></ul><ul data-rte-list=\"default\"><li>Awarded the Silver Engage Watermark in recognition of our outstanding commitment to supporting public engagement</li></ul><ul data-rte-list=\"default\"><li>Awarded \u00a34.3m by the Office for Students to create, expand and modernise courses and facilities in healthcare and STEM subject areas.</li></ul>\t\t\n\t\t<h3>Videos</h3>https://www.youtube.com/watch?v=CW2zVJebmTohttps://www.youtube.com/watch?v=Kn2qZCN5GS0https://www.youtube.com/watch?v=3C-Qas6Qekwhttps://www.youtube.com/watch?v=3ozN9Ke1y5k&#038;t=34shttps://www.youtube.com/watch?v=HwgBERD2VQs\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p><strong>Foundation Entry</strong></p><p>\u00a0</p><ul><li>High School Graduation Diploma \u2013 minimum 2.75 GPA</li></ul><p>\u00a0</p><p><strong>Undergraduate Entry</strong></p><p>\u00a0</p><ul><li>High School Graduation Diploma \u2013 minimum 2.8 GPA</li></ul><p>\u00a0</p><p>With (one or more of the following)</p><p>\u00a0</p><ul><li>SAT scores (1100 in Maths, Critical Thinking &amp; Writing or 370 in a relevant subject; current system)</li><li>ACT scores (24 overall in 2 or more subjects)</li><li>AP scores (minimum grade 3 in 2 relevant subjects)</li></ul>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<p>BA (Hons) Interior Design<br />BA (Hons) Architectural Design and Technology<br />BSc (Hons) Quantity Surveying<br />BSc (Hons) Construction Management<br />BSc (Hons) Construction Management (Part-Time)<br />BSc (Hons) International Construction, Design Sustainability (top-up)<br />HNC Architectural Technology<br />HNC Civil Engineering<br />HNC Construction Management<br />HNC Quantity Surveying<br />BA (Hons) Fine Art<br />BA (Hons) Graphic Design<br />BA (Hons) Illustration<br />BA (Hons) Interior Design Decoration<br />BA (Hons) Photography<br />BA (Hons) Prosthetics and Special Effects Design<br />BSc (Hons) Accountancy and Finance<br />BSc (Hons) Business Management <br />BSc (Hons) Business Management with Digital Technologies<br />BSc (Hons) Business Management with Finance<br />BSc (Hons) Business Management with Marketing<br />BSc (Hons) International Business Management<br />BSc (Hons) Computer Network Engineering<br />BSc (Hons) Computer Science<br />BSc (Hons) Cyber Security<br />BSc (Hons) Software Engineering<br />HNC Cyber Security Technologist<br />HNC Data Analyst<br />HNC Network Engineer<br />BA (Hons) Animation<br />BA (Hons) CGI and Visual Effects<br />BA (Hons) Computer Games (Art)<br />BA (Hons) Digital and Game Art Top-Up<br />BSc (Hons) Computer Games Programming and Design<br />BEng (Hons) Electronic Engineering<br />BEng (Hons) Mechanical Engineering<br />BEng (Hons) Renewable Energy Engineering<br />BEng (Hons) Yacht and Powercraft Design<br />BEng (Hons) Yacht Design and Production<br />HNC Engineering<br />BA (Hons) Sports Journalism<br />BA (Hons) Fashion Design<br />BA (Hons) Fashion Management with Marketing<br />BA (Hons) Fashion and Beauty Media<br />BA (Hons) Fashion Photography<br />BA (Hons) Fashion Styling and Creative Direction<br />BA (Hons) Make-Up and Hair Design<br />BA (Hons) Film and Television<br />BA (Hons) Film Production<br />BA (Hons) Media Production<br />BA (Hons) Post Production for Film and Television<br />BA (Hons) Television Production<br />BSc (Hons) Live Event Technology<br />BSc (Hons) Adult Nursing Practice<br />BSc (Hons) Biomedical Science<br />FdSc Health and Social Care (Health Care Assistant Practitioner<br />FdSc Health and Social Care (Nursing Associate)<br />FdSc Health Care Play Specialism<br />LLB (Hons) Law<br />BSc (Hons) Maritime Business<br />BSc (Hons) Maritime Management Top-Up<br />BSc (Hons) Maritime Sciences<br />BSc (Hons) Shipping and Port Management<br />FdEng Marine Engineering<br />FdSc Nautical Science<br />HND Marine Electrical and Electronic Engineering<br />HND Nautical Science<br />BEng (Hons) Marine Electrical and Electronic Engineering<br />BEng (Hons) Marine Engineering<br />BSc (Hons) Nautical Science<br />BA (Hons) Acting and Performance<br />BA (Hons) Digital Music<br />BA (Hons) Music Business<br />BA (Hons) Musical Theatre<br />BA (Hons) Popular Music Performance and Production<br />BMus (hons) Popular Music Performance<br />BSc (Hons) Popular Music Production<br />BSc (Hons) Mental Health Nursing<br />BSc (Hons) Psychology<br />BSc (Hons) Psychology with Counselling and Mental Health<br />BSc (Hons) Psychology and Sociology<br />BSc (Hons) Sport and Exercise Psychology<br />BA (Hons) Criminology<br />BA (Hons) Criminology and Sociology<br />BA (Hons) Social Work<br />BA (Hons) Sociology<br />BSc (Hons) Criminal Investigation with Psychology<br />BSc (Hons) Criminology and Psychology<br />BA (Hons) Physical Education<br />BA (Hons) Sport Coaching and Physical Education (Top-Up)<br />BSc (Hons) Sport and Exercise Therapy<br />BSc (Hons) Football Studies<br />BSc (Hons) Health, Nutrition and Exercise Science<br />BSc (Hons) Sport and Exercise Science<br />BSc (Hons) Sport Coaching<br />BSc (Hons) Sport Management <br />BA (Hons) Education <br />LLB (Hons) Law with Business<br />LLB (Hons) Law with Criminology</p>\n\t\t\t<a href=\"https://www.solent.ac.uk/courses\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>Postgraduate degree US entry requirements Honours degree at 2:2 or higher in any discipline, or extensive industrial experience in subject area.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<p>MSc Sustainable Construction Management<br />MSc Sustainable Refurbishment<br />MSc Sustainable Building Design<br />MA Fine Art (Coming Soon)<br />MA Visual Communication<br />MA Internal Communication Management (ran by IoIC)<br />MBA Global Master of Business Administration<br />MSc Project Management<br />MSc Digital Marketing<br />MSc Financial Management<br />MSc Logistics Management<br />MSc Strategic Management<br />MSc Applied AI and Data Science<br />MSc Computer Engineering<br />MSc Cyber Security Engineering<br />MSc Digital Design<br />MSc Sustainable Marine Craft and Superyacht Design (Coming Soon)<br />MA Sports Broadcast Journalism<br />MA Creative Direction for Fashion and Beauty<br />MA Digital Fashion<br />MA Make-up and Hair Design Futures<br />MA Film Production<br />MA Post Production in Film and Television<br />Independent and Supplementary Prescribing<br />MSc General Practice (Nursing and Allied Health Professionals)<br />PGCert Independent Prescribing Practice<br />LLM Commercial Law and Professional Legal Practice<br />LLM Intellectual Property Law and Professional Legal Practice<br />MSc International Maritime Business<br />MSc International Shipping and Logistics<br />MSc Shipping Operations<br />MA Social Work<br />PGDip Social Work (Coming Soon)<br />MA Physical Education and School Sport<br />MA Sport Management<br />MSc Clinical Exercise Science<br />MSc Football Science<br />MSc Sport and Exercise Medicine in Football<br />MSc Sport Science for Performance Coaching<br />MSc Strength and Conditioning</p>\n\t\t\t<a href=\"https://www.solent.ac.uk/courses\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"http://facebook.com/solentuniversity\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://twitter.com/solentuni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"http://instagram.com/solentuniversity\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.youtube.com/@SolentUni\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"http://solent.ac.uk\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/international/country-specific-information/united-states\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/finance/tuition-fees\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/finance/scholarships\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/events\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/research-innovation-enterprise/research-at-solent\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/accommodation/find-a-home\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solent.ac.uk/studying-at-solent/student-support/career-employability-advice\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.solentsu.co.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"https://www.solent.ac.uk/how-to-apply\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"Southampton Solent University","post_link":"https://theukstudyexpert.com/universities/southampton-solent-university/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Southampton Solent University\" width=\"300\" height=\"300\" src=\"https://theukstudyexpert.com/wp-content/uploads/2024/03/southampton-solent-logo-full-color-rgb-900px-w-72ppi-1-1-300x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, England, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"2","taxonomy=category":"Universities","taxonomy=post_tag":"2.6-2.89, 2.9, 3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Education, England, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"Southampton, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":13844,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"King&#8217;s College London","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"King&#039;s College London\" width=\"300\" height=\"240\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Kings-College-London-e1725894283670-300x240.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/kings-college-london/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">King&#8217;s College London</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                King's is a globally recognised university and is currently ranked 3rd in London, 7th in the UK, and 31st in the world (QS World University Rankings 2021). King\u2019s has over 36,000 students from 185 different countries around the globe.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"King's is a globally recognised university and is currently ranked 3rd in London, 7th in the UK, and 31st in the world (QS World University Rankings 2021). King\u2019s has over 36,000 students from 185 different countries around the globe.","address":"Stamford St, London SE1 9NH, UK","location":{"lat":"51.5056185","state":"England","country":"United Kingdom","lng":"-0.113562","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/kings-college-london/","zoom":5,"extra_fields":{"post_excerpt":"King's is a globally recognised university and is currently ranked 3rd in London, 7th in the UK, and 31st in the world (QS World University Rankings 2021). King\u2019s has over 36,000 students from 185 different countries around the globe.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Picture4.jpg\" alt=\"Picture4\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Picture8.jpg\" alt=\"Picture8\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Picture1.jpg\" alt=\"Picture1\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Picture5.jpg\" alt=\"Picture5\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/campus1.jpg\" alt=\"campus+(1)\" /></figure><figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Picture3.jpg\" alt=\"Picture3\" /></figure>\t\t\t\n\t\t\t<a href=\"#contact-form\">\n\t\t\t\t\t\t\t\t\tContact King\u2019s College London\n\t\t\t\t\t</a>\n\t\t<p><strong>Location:</strong> JCMB, 57 Waterloo Road, London, SE1 8WA United Kingdom</p><p><strong>Website:</strong> <a href=\"https://www.kcl.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://kcl.ac.uk/</a></p><h3>Overview</h3><p>The 4th oldest university in England, King's is ranked in the top 10 UK universities in the world with 5 campuses based in the heart of London. King\u2019s has over 36,000 students from 185 different countries around the globe, representing a diverse and multicultural community much like the city of London itself.</p><p>\u00a0</p><p>King's is part of the elite Russell Group, which means research is at the heart of our undergraduate and postgraduate student experiences. And with the oldest and one of the most active students' unions in the UK, community is also a core value to the King's campus. Our 2029 strategic vision focuses on civic engagement, truly making King's an impactful institution in the great city of London.</p><p>\u00a0</p><p><strong>Population: </strong>36,000</p><p><strong>Campus Type: </strong>Urban</p>\t\t\n\t\t<h3>Quick Facts</h3><ul data-rte-list=\"default\"><li><p>Founded in 1829 by King George IV and the Duke of Wellington.</p></li><li><p>5 campuses situated across central London.</p></li><li><p>9 academic faculties with over 175 programmes.</p></li><li><p>Ranked #35 in the QS World University Rankings 2022.</p></li><li><p>King's College London Students' Union (KCLSU) is the oldest students' union in the UK, founded in 1873 as the Union Society of King's College London.</p></li></ul>\t\t\n\t\t<h3>Videos</h3>https://youtu.be/7pmQ7xWkGcshttps://youtu.be/1trvO6dqQUIhttps://youtu.be/gOCDnIuM664https://youtu.be/TaQQLdDE3Pkhttps://youtu.be/sjivp96REo8https://www.youtube.com/watch?v=kMHQWFBZL_A\t\t\n\t\t<h3>Undergraduate Information</h3><h4>US Entry Requirements</h4><p>Applicants with US high school qualifications can meet our entry requirements through a combination of APs, Honors/Dual Enrolment Class, SATs and ACTs* listed below.<br /><br /></p><p>*Please note we will only consider Honors/Dual Enrolment Class, for US-domiciled applicants only, if the school does not teach enough AP subjects. Honors Classes must be taken for one year at grade 12 level, and Dual Enrolment (College) Classes must be taken for one semester of at least 3 credits. We do not allow Honors Classes to meet subject requirements but we consider Dual Enrolment (College) Classes on a case-by-case basis. We no longer consider SAT subject tests. We cannot consider ACT Super Scores.<br /><br /></p><p>High School Diploma plus one of the following:</p><p>\u00a0</p><ul data-rte-list=\"default\"><li><p>5 AP\u2019s*</p></li><li><p>3 AP\u2019s and the SAT (minimum 1300)</p></li><li><p>3 AP\u2019s* and the ACT (minimum 27)</p></li></ul><p>Please see further information by specific subject <a href=\"https://www.kcl.ac.uk/study/undergraduate/how-to-apply/entry-requirements#section-10\">here</a>.\u00a0</p><p><br />OR<br /><br /></p><ul data-rte-list=\"default\"><li><p>International Baccalaureate Diploma*</p></li><li><p>French Baccalaureate Diploma*</p></li></ul><p><br />*Applicants must study three subjects in-depth, including any subjects stated in their online prospectus as \u2018compulsory\u2019 for your programme.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Undergraduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Arts &amp; Humanities</li><li>Business</li><li>Dentistry, Oral &amp; Craniofacial Sciences</li><li>Law</li></ul><ul id=\"majors\"><li>Life Sciences &amp; Medicine</li><li>Natural, Mathematical &amp; Engineering Sciences</li><li>Nursing, Midwifery &amp; Palliative Care</li><li>Psychiatry, Psychology &amp; Neuroscience</li><li>Social Science &amp; Public Policy</li></ul>\n\t\t\t<a href=\"https://www.kcl.ac.uk/study/undergraduate/apply\">\n\t\t\t\t\t\t\t\t\tMore Info on Undergraduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Graduate Information</h3><h4>US Entry Requirements</h4><p>Minimum GPA 3.0 - 3.7 depending on the programme.</p>\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t<a tabindex=\"0\">View All Graduate Majors</a>\n\t\t\t\t\t<ul id=\"majors\"><li>Arts &amp; Humanities</li><li>Business</li><li>Dentistry, Oral &amp; Craniofacial Sciences</li><li>Law</li></ul><ul id=\"majors\"><li>Life Sciences &amp; Medicine</li><li>Natural, Mathematical &amp; Engineering Sciences</li><li>Nursing, Midwifery &amp; Palliative Care</li><li>Psychiatry, Psychology &amp; Neuroscience</li><li>Social Science &amp; Public Policy</li></ul>\n\t\t\t<a href=\"https://www.kcl.ac.uk/study/postgraduate/apply\">\n\t\t\t\t\t\t\t\t\tMore Info on Graduate Degrees\n\t\t\t\t\t</a>\n\t\t<h3>Social Media</h3>\t\t\n\t\t\t\t\t<a href=\"https://www.facebook.com/kingscollegelondon\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tFacebook\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://twitter.com/KingsCollegeLon\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tTwitter\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.instagram.com/LifeAtKings/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tInstagram\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t<a href=\"https://www.youtube.com/user/kingscollegelondon\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\tYoutube\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t<h3>Additional University Links</h3>\t\t\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.kcl.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHome Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.kcl.ac.uk/study/international/offices/north-america/usa\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tUSA/International Page\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.kcl.ac.uk/study/international/fees-and-funding\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tInternational Tuition\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.kcl.ac.uk/study/scholarships/index\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tScholarships\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://apply.kcl.ac.uk/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tFAFSA\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.kcl.ac.uk/events\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tVirtual Events\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://kclpure.kcl.ac.uk/portal/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tResearch\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.kcl.ac.uk/accommodation\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tHousing/Accommodation\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.kcl.ac.uk/careers\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tCareers Office\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t\t\t<li>\n\t\t\t\t\t\t\t\t\t\t\t<a href=\"https://www.kclsu.org/\" target=\"_blank\" rel=\"noopener\">\n\t\t\t\t\t\t\t\t\t\t\tClubs/Societies\n\t\t\t\t\t\t\t\t\t\t\t</a>\n\t\t\t\t\t\t\t\t\t</li>\n\t\t\t\t\t\t</ul>\n\t\t\t<a href=\"https://google.com/\">\n\t\t\t\t\t\t\t\t\tAPPLY NOW\n\t\t\t\t\t</a>\n\t\t\t<h3>REQUEST MORE INFORMATION</h3>\t\t\n\t\t<p>[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]</p>","post_title":"King&#8217;s College London","post_link":"https://theukstudyexpert.com/universities/kings-college-london/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"King&#039;s College London\" width=\"300\" height=\"240\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Kings-College-London-e1725894283670-300x240.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","%_custom_priority_meta_key%":"1","taxonomy=category":"Universities","taxonomy=post_tag":"3.0, 3.1, 3.2, 3.3+, Business Economics, Creativeperforming Arts Design, Engineering, England, Health Medicine, Humanities, Life Physical Sciences, Social Science, Technology Computer Science","city_country":"London, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10243,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"Imperial College London","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Imperial College London\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Untitled-design-21-e1712874673508-300x158.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/imperial-college-london/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Imperial College London</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Imperial is one of the world\u2019s 10 top universities (QS World Rankings 2022), in one of its most iconic cities \u2013 London, UK. Today we have one of the highest concentrations of high-impact research of any major UK university.\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Imperial is one of the world\u2019s 10 top universities (QS World Rankings 2022), in one of its most iconic cities \u2013 London, UK. Today we have one of the highest concentrations of high-impact research of any major UK university.","address":"Exhibition Rd, South Kensington, London SW7 2BX, UK","location":{"lat":"51.49882220000001","state":"England","country":"United Kingdom","lng":"-0.1748735","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/imperial-college-london/","zoom":5,"extra_fields":{"post_excerpt":"Imperial is one of the world\u2019s 10 top universities (QS World Rankings 2022), in one of its most iconic cities \u2013 London, UK. Today we have one of the highest concentrations of high-impact research of any major UK university.","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/lab800x800.jpg\" alt=\"lab+800+x+800\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/151006_freshers_fair_106_180748_001.jpg\" alt=\"151006_freshers_fair_106_180748_001\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/150513_scholars_002_172963_001.jpg\" alt=\"150513_scholars_002_172963_001\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/180212_aeronautics_019.jpg\" alt=\"180212_aeronautics_019\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/0190307_horizons_advanced_hackspace_011.jpg\" alt=\"0190307_horizons_advanced_hackspace_011\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/icl-exhibrdentrance-101_135455_001.jpg\" alt=\"icl-exhibrdentrance-101_135455_001\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact Imperial College London\r\n</a>\r\n\r\n<strong>Location:</strong> South Kensington Campus, Exhibition Road, London, SW7 2AZ, UK\r\n\r\n<strong>Website:</strong> <a href=\"https://www.imperial.ac.uk/\" target=\"_blank\" rel=\"noopener\">https://imperial.ac.uk/</a>\r\n<h3>Overview</h3>\r\nImperial College London a world\u2013leading university for science, technology, engineering, medicine and business, in one of its most iconic cities \u2013 London, UK.\r\n\r\n&nbsp;\r\n\r\nWe were founded in 1907 with a mission \u2018To be useful\u2019 \u2013 but we know that before anyone can usefully change something, they first need to understand it.\u00a0 That\u2019s what we do: We use science to try to understand more of the universe, and improve the lives of more people in it.\r\n\r\n&nbsp;\r\n\r\nToday, Imperial has one of the highest concentrations of high-impact research of any major UK university. The research and innovations we produce are right now helping to navigate some of the world\u2019s toughest challenges in global health, climate change, AI, business leadership and more. We are a truly global community, bringing together the best people from around the world to the heart of one world\u2019s most exciting cities. With students from over 140 countries, and a specialist community and a research-led curriculum our degrees open doors and our discoveries change lives.\r\n\r\n&nbsp;\r\n\r\n<strong>Population: </strong>20,000\r\n\r\n<strong>Campus Type: </strong>Urban\r\n<h3>Quick Facts</h3>\r\n<ul data-rte-list=\"default\">\r\n \t<li>Imperial College is the only UK university to focus entirely on science, engineering, medicine and business.</li>\r\n \t<li>Ranked 7th in the world (QS World Rankings) 5th Most International University in the world (Times Higher Education).</li>\r\n \t<li>Over 50% of Imperial College students come from outside the UK, from over 130 different countries</li>\r\n \t<li>380 clubs and societies - From baking to biking, and from hip hop to Harry Potter \u2013 whatever inspires you, you\u2019ll find like-minded people to share it with at Imperial College.</li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=QUBsf-2GX5shttps://youtu.be/FyoM7fhJ1_4https://www.youtube.com/watch?v=2_hGbm-cXlMhttps://youtu.be/RgnviWci1Z0\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nImperial College requires a minimum of 3-4 AP tests with Grades of 5 (with specific subjects). Expected to be taken alongside a relevant high school diploma.\r\n\r\n<strong>\u00a0</strong>\r\n\r\n<strong>Deadlines</strong>\r\n\r\nMedicine - October 15\r\n\r\nOther - Equal Consideration Deadline (Mid-January - changes every year)\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n<ul id=\"majors\">\r\n \t<li><strong>Fall Intake</strong></li>\r\n \t<li>Addiction and Mental Health MSc</li>\r\n \t<li>Architectural History, Research and Writing MA</li>\r\n \t<li>Architecture \u2013 RIBA 2</li>\r\n \t<li>Architecture Apprenticeship (RIBA 2 and 3) \u2013 MArch</li>\r\n \t<li>Child and Adolescent Mental Health MSc</li>\r\n \t<li>Conference Interpreting \u2013 MA</li>\r\n \t<li>Corporate Social Responsibility and Sustainability \u2013 Adv Dip Pro Dev</li>\r\n \t<li>Cryptography MSc</li>\r\n \t<li>Culture, Heritage and Leisure Management \u2013 MSc/PG Dip/PG Cert</li>\r\n \t<li>Design for Cultural Commons \u2013 PG Cert</li>\r\n \t<li>Design for Cultural Commons \u2013 PG Dip</li>\r\n \t<li>Dietetics and Nutrition \u2013 MSc</li>\r\n \t<li>Documentary Film Production \u2013 MA</li>\r\n \t<li>Employment Law and Practice \u2013 Advance Diploma Prof Dev</li>\r\n \t<li>Environmental, Sustainable and Regeneration Design MA</li>\r\n \t<li>Fine Arts \u2013 MFA</li>\r\n \t<li>Furniture Design \u2013 MA</li>\r\n \t<li>Human Resource Management \u2013 PG Dip</li>\r\n \t<li>Interior Design \u2013 MA</li>\r\n \t<li>International Accounting and Finance MSc</li>\r\n \t<li>Interpreting \u2013 MA</li>\r\n \t<li>Jewellery and Silversmithing \u2013 MA</li>\r\n \t<li>Law: Common Professional Exam \u2013 GDL</li>\r\n \t<li>Legal Practice Course \u2013 PG Dip</li>\r\n \t<li>LLM Legal Practice</li>\r\n \t<li>LLM Legal Practice (Top-up) \u2013 LLM</li>\r\n \t<li>Master of Philosophy (MPhil)</li>\r\n \t<li>PGCE Early Years (3 \u2013 7) \u2013 PGCE</li>\r\n \t<li>PGCE Primary 5-11 \u2013 PGCE</li>\r\n \t<li>PGCE Secondary English with Drama \u2013 PGCE</li>\r\n \t<li>PGCE Secondary English with Media \u2013 PGCE</li>\r\n \t<li>PGCE Secondary Mathematics \u2013 PGCE</li>\r\n \t<li>PGCE Secondary Modern Languages \u2013 PGCE</li>\r\n \t<li>PGCE Secondary Science with Biology \u2013 PGCE</li>\r\n \t<li>PGCE Secondary Science with Chemistry \u2013 PGCE</li>\r\n \t<li>PGCE Secondary Science with Physics \u2013 PGCE</li>\r\n \t<li>Primary (7-11) (Key Stage 2) \u2013 PGCE</li>\r\n \t<li>Product Design \u2013 MA</li>\r\n \t<li>Public Art and Performance \u2013 MA</li>\r\n \t<li>Robotics with Artificial Intelligence \u2013 MSc</li>\r\n \t<li>Social Work \u2013 MSc</li>\r\n \t<li>Specialised Translation PG Cert</li>\r\n \t<li>Sports Therapy \u2013 MSc</li>\r\n \t<li>Textile Design \u2013 MA</li>\r\n \t<li>Translation \u2013 MA</li>\r\n \t<li>Translation Technology PG Cert</li>\r\n \t<li>Visual Communication: Graphic Design</li>\r\n \t<li>Visual Communication: Illustration</li>\r\n</ul>\r\n<ul id=\"majors\">\r\n \t<li><strong>January Intake</strong></li>\r\n \t<li>Architecture: Professional Practice in Architecture \u2013 RIBA 3</li>\r\n \t<li>Artificial Inteligence MA</li>\r\n \t<li>Assessment only (AO) route to Qualified Teacher Status \u2013 QTS</li>\r\n \t<li>Aviation Management in the Digital Age \u2013 MSc</li>\r\n \t<li>Biomedical Science \u2013 MSc</li>\r\n \t<li>Biomedical Studies Distance Learning \u2013 MSc</li>\r\n \t<li>Blood Science \u2013 MSc</li>\r\n \t<li>Blood Science Distance Learning \u2013 MSc</li>\r\n \t<li>Cancer Immunotherapy \u2013 MSc</li>\r\n \t<li>Cancer Pharmacology \u2013 MSc</li>\r\n \t<li>Computer Networking and Cyber Security \u2013 MSc</li>\r\n \t<li>Computer Networking and Cyber Security with Work Experience \u2013 MSc</li>\r\n \t<li>Corporate Social Responsibility and Sustainability \u2013 MSc</li>\r\n \t<li>Creative Digital and Professional Writing \u2013 MA</li>\r\n \t<li>Criminology \u2013 MSc</li>\r\n \t<li>Data Analytics \u2013 MSc</li>\r\n \t<li>Digital Media \u2013 MA</li>\r\n \t<li>Doctor of Philosophy \u2013 MPhil / PhD</li>\r\n \t<li>Early Childhood Studies \u2013 MA</li>\r\n \t<li>Education \u2013 MA</li>\r\n \t<li>English Language Teaching (Distance Learning) \u2013 MA</li>\r\n \t<li>Financial Services Law, Regulation and Compliance \u2013 LLM/PG Dip/PG Cert</li>\r\n \t<li>Food Science \u2013 MSc</li>\r\n \t<li>Health and Social Care Management and Policy \u2013 MSc</li>\r\n \t<li>Human Nutrition and (Public Health/Sports) \u2013 MSc</li>\r\n \t<li>Human Resource Management \u2013 MA</li>\r\n \t<li>Human Rights and International Conflict \u2013 MA</li>\r\n \t<li>Information Technology Distance Learning \u2013 MSc</li>\r\n \t<li>International Banking and Finance MSc</li>\r\n \t<li>International Business Management MSc</li>\r\n \t<li>International Business Management with Project Management MSc</li>\r\n \t<li>International Events, Leisure and Tourism Management</li>\r\n \t<li>International Relations \u2013 MA</li>\r\n \t<li>International Trade and Finance \u2013 MSc</li>\r\n \t<li>Learning and Teaching in Higher Education \u2013 MA</li>\r\n \t<li>Maritime law (Top-Up) (Distance Learning) -LLM</li>\r\n \t<li>Maritime Law LLM/PG Dip/PG Cert</li>\r\n \t<li>Marketing \u2013 MA</li>\r\n \t<li>Master of Business Administration</li>\r\n \t<li>Media Law LLM/PG Dip/PG Cert</li>\r\n \t<li>Medical Genomics \u2013 MSc</li>\r\n \t<li>Organised Crime and Global Security \u2013 MA</li>\r\n \t<li>Pharmaceutical Science and Drug Delivery Systems \u2013 MSc</li>\r\n \t<li>Public Health \u2013 MSc</li>\r\n \t<li>Teaching Languages (Arabic) \u2013 MA</li>\r\n \t<li>Teaching Languages (English) \u2013 MA</li>\r\n \t<li>Technology Entrepreneurship \u2013 MSc</li>\r\n \t<li>Youth and Community Work (Advanced Practice) \u2013 MSc</li>\r\n \t<li>Youth and Community Work (with JNC Recognition) \u2013 MSc</li>\r\n</ul>\r\n<a href=\"https://www.imperial.ac.uk/study/ug/courses/\">\r\nMore Info on Undergraduate Degrees\r\n</a>\r\n<h3>Graduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nOur minimum requirement is based on the university's selectivity ranking so minimum grade requirements will range from 3.0 / 4.0 to 3.6 / 4.0 depending on the institution.\r\n\r\n<a tabindex=\"0\">View All Graduate Majors</a>\r\n<ul id=\"majors\">\r\n \t<li>Advanced Aeronautical Engineering MSc</li>\r\n \t<li>Advanced Chemical Engineering MSc</li>\r\n \t<li>Advanced Chemical Engineering with Biotechnology MSc</li>\r\n \t<li>Advanced Chemical Engineering with Process Systems Engineering MSc</li>\r\n \t<li>Advanced Chemical Engineering with Structured Product Engineering MSc</li>\r\n \t<li>Advanced Computational Methods for Aeronautics, Flow Management and Fluid-Structure Interaction MSc</li>\r\n \t<li>Advanced Computing MSc</li>\r\n \t<li>Advanced Materials for Sustainable Infrastructure MSc</li>\r\n \t<li>Advanced Materials Science and Engineering MSc</li>\r\n \t<li>Advanced Mechanical Engineering MSc</li>\r\n \t<li>Advanced Molecular Synthesis MRes</li>\r\n \t<li>Allergy PG Cert</li>\r\n \t<li>Allergy PG Dip</li>\r\n \t<li>Allergy MSc</li>\r\n \t<li>Analogue and Digital Integrated Circuit Design MSc</li>\r\n \t<li>Applied Biosciences and Biotechnology MSc</li>\r\n \t<li>Applied Computational Science and Engineering MSc</li>\r\n \t<li>Applied Genomics MSc</li>\r\n \t<li>Applied Machine Learning MSc</li>\r\n \t<li>Applied Mathematics MSc</li>\r\n \t<li>Applied Paediatrics MSc</li>\r\n \t<li>Applied Paediatrics PG Cert</li>\r\n \t<li>Applied Paediatrics PG Dip</li>\r\n \t<li>Artificial Intelligence MSc</li>\r\n \t<li>Bioengineering MRes</li>\r\n \t<li>Bioinformatics and Theoretical Systems Biology MSc</li>\r\n \t<li>Biological and Physical Chemistry MRes</li>\r\n \t<li>Biomedical Engineering MSc</li>\r\n \t<li>Biomedical Research MRes</li>\r\n \t<li>Biomedical Research (Anaesthetics, Pain Medicine and Intensive Care) MRes</li>\r\n \t<li>Biomedical Research (Bacterial Pathogenesis and Infection) MRes</li>\r\n \t<li>Biomedical Research (Data Science) MRes</li>\r\n \t<li>Biomedical Research (Epidemiology, Evolution and Control of Infectious Diseases) MRes</li>\r\n \t<li>Biomedical Research (Microbiome in Health and Disease) MRes</li>\r\n \t<li>Biomedical Research (Molecular Basis of Human Disease) MRes</li>\r\n \t<li>Biomedical Research (Respiratory and Cardiovascular Science) MRes</li>\r\n \t<li>Biosystematics MRes</li>\r\n \t<li>Business MRes</li>\r\n \t<li>Business Analytics MSc</li>\r\n \t<li>Business Analytics (Online) MSc</li>\r\n \t<li>Cancer Biology MRes</li>\r\n \t<li>Cancer Informatics MRes</li>\r\n \t<li>Cancer Technology MRes</li>\r\n \t<li>Cardiovascular and Respiratory Healthcare PG Cert</li>\r\n \t<li>Cardiovascular and Respiratory Healthcare PG Dip</li>\r\n \t<li>Cardiovascular and Respiratory Healthcare MSc</li>\r\n \t<li>Catalysis: Chemistry and Engineering MRes</li>\r\n \t<li>Chemical Biology and Bio-Entrepreneurship MRes</li>\r\n \t<li>Climate Change, Management and Finance MSc</li>\r\n \t<li>Clinical Research MRes</li>\r\n \t<li>Clinical Research PG Cert</li>\r\n \t<li>Communications and Signal Processing MSc</li>\r\n \t<li>Composites: the Science, Technology and Engineering Application of Advanced Composites MSc</li>\r\n \t<li>Computational Methods in Ecology and Evolution MRes</li>\r\n \t<li>Computational Methods in Ecology and Evolution MSc</li>\r\n \t<li>Computing MSc</li>\r\n \t<li>Computing (Artificial Intelligence and Machine Learning) MSc</li>\r\n \t<li>Computing (Management and Finance) MSc</li>\r\n \t<li>Computing (Security and Reliability) MSc</li>\r\n \t<li>Computing (Software Engineering) MSc</li>\r\n \t<li>Concrete Structures MSc</li>\r\n \t<li>Control Systems MSc</li>\r\n \t<li>Digital Chemisty MSc</li>\r\n \t<li>Digital Chemisty MSc</li>\r\n \t<li>Digital Health Leadership PG Dip</li>\r\n \t<li>Drug Discovery and Development: Multidisciplinary Science for Next Generation Therapeutics MRes</li>\r\n \t<li>Earthquake Engineering MSc</li>\r\n \t<li>Ecological Applications MSc</li>\r\n \t<li>Ecology, Evolution and Conservation MSc</li>\r\n \t<li>Ecology, Evolution and Conservation Research MRes</li>\r\n \t<li>Economics and Strategy for Business MSc</li>\r\n \t<li>Ecosystem and Environmental Change MRes</li>\r\n \t<li>Engineering Fluid Mechanics for the Offshore, Coastal and Built Environments MSc</li>\r\n \t<li>Engineering for Biomedicine MSc</li>\r\n \t<li>Environmental Data Science and Machine Learning MSc</li>\r\n \t<li>Environmental Engineering MSc</li>\r\n \t<li>Environmental Technology MSc</li>\r\n \t<li>Epidemiology MSc</li>\r\n \t<li>Experimental Neuroscience MRes</li>\r\n \t<li>Finance MSc</li>\r\n \t<li>Finance and Accounting MSc</li>\r\n \t<li>Financial Technology MSc</li>\r\n \t<li>Future Power Networks MSc</li>\r\n \t<li>General Structural Engineering MSc</li>\r\n \t<li>Genes, Drugs and Stem Cells \u2013 Novel Therapies</li>\r\n \t<li>Genomic Medicine PG Cert</li>\r\n \t<li>Genomic Medicine PG Dip</li>\r\n \t<li>Genomic Medicine MSc</li>\r\n \t<li>Geo-Energy with Machine Learning and Data Science MSc</li>\r\n</ul>\r\n<ul id=\"majors\">\r\n \t<li>Global Innovation Design MA/MSc</li>\r\n \t<li>Global Master of Public Health (Online) MPH</li>\r\n \t<li>Global Statistics (Online) MSc</li>\r\n \t<li>Green Chemistry, Energy and the Environment MRes</li>\r\n \t<li>Health Data Analytics and Machine Learning MSc</li>\r\n \t<li>Health Policy PG Cert</li>\r\n \t<li>Health Policy PG Dip</li>\r\n \t<li>Health Policy MSc</li>\r\n \t<li>Healthcare and Design MSc</li>\r\n \t<li>Healthcare and Design PG Dip</li>\r\n \t<li>Human and Biological Robotics MSc</li>\r\n \t<li>Human Molecular Genetics MSc</li>\r\n \t<li>Hydrology and Water Resources Management MSc</li>\r\n \t<li>Immunology PG Cert</li>\r\n \t<li>Immunology MSc</li>\r\n \t<li>Innovation Design Engineering MA/MSc</li>\r\n \t<li>Innovation, Entrepreneurship and Management MSc</li>\r\n \t<li>International Health Management MSc</li>\r\n \t<li>International Management MSc</li>\r\n \t<li>Investment and Wealth Management MSc</li>\r\n \t<li>Machine Learning and Big Data in the Physical Sciences MRes</li>\r\n \t<li>Machine Learning and Data Science (Online) MSc</li>\r\n \t<li>Management MSc</li>\r\n \t<li>Mathematics and Finance MSc</li>\r\n \t<li>MBA MBA</li>\r\n \t<li>MBA (Executive) MBA</li>\r\n \t<li>MBA (Global Online) MBA</li>\r\n \t<li>MBA (Weekend) MBA</li>\r\n \t<li>Medical Device Design and Entrepreneurship MRes</li>\r\n \t<li>Medical Robotics and Image-Guided Intervention MRes</li>\r\n \t<li>Medical Ultrasound (Echocardopgraphy and Vascular) MSc</li>\r\n \t<li>Metals and Energy Finance MSc</li>\r\n \t<li>Molecular and Cellular Biosciences MRes</li>\r\n \t<li>Molecular Biology and Pathology of Viruses MSc</li>\r\n \t<li>Molecular Engineering MRes</li>\r\n \t<li>Molecular Medicine MSc</li>\r\n \t<li>Molecular Plant and Microbial Sciences MRes</li>\r\n \t<li>Nanomaterials MRes</li>\r\n \t<li>Neurotechnology MRes</li>\r\n \t<li>Optics and Photonics MSc</li>\r\n \t<li>Applied Paediatrics PG Cert</li>\r\n \t<li>Applied Paediatrics PG Dip</li>\r\n \t<li>Applied Paediatrics MSc</li>\r\n \t<li>Patient Safety PG Cert</li>\r\n \t<li>Patient Safety PG Dip</li>\r\n \t<li>Patient Safety MSc</li>\r\n \t<li>Photonics MRes</li>\r\n \t<li>Physics MSc</li>\r\n \t<li>Physics with Extended Research MSc</li>\r\n \t<li>Physics with Nanophotonics MSc</li>\r\n \t<li>Physics with Quantum Dynamics MSc</li>\r\n \t<li>Public Health MPH</li>\r\n \t<li>Pure Mathematics MSc</li>\r\n \t<li>Quantum Fields and Fundamental Forces MSc</li>\r\n \t<li>Reproductive and Developmental Biology PG Cert</li>\r\n \t<li>Reproductive and Developmental Biology MSc</li>\r\n \t<li>Risk Management and Financial Engineering MSc</li>\r\n \t<li>Science Communication MSc</li>\r\n \t<li>Science Media Production MSc</li>\r\n \t<li>Security and Resilience: Science and Technology PG Cert</li>\r\n \t<li>Security and Resilience: Science and Technology PG Dip</li>\r\n \t<li>Security and Resilience: Science and Technology MSc</li>\r\n \t<li>Soft Electronic Materials MRes</li>\r\n \t<li>Soil Mechanics MSc</li>\r\n \t<li>Soil Mechanics and Engineering Geology MSc</li>\r\n \t<li>Soil Mechanics and Engineering Seismology MSc</li>\r\n \t<li>Soil Mechanics and Environmental Geotechnics MSc</li>\r\n \t<li>Statistics MSc</li>\r\n \t<li>Statistics (Applied Statistics) MSc</li>\r\n \t<li>Statistics (Biostatistics) MSc</li>\r\n \t<li>Statistics (Data Science) MSc</li>\r\n \t<li>Statistics (Statistical Finance) MSc</li>\r\n \t<li>Statistics (Theory and Methods) MSc</li>\r\n \t<li>Strategic Marketing MSc</li>\r\n \t<li>Strategic Marketing (Online) MSc</li>\r\n \t<li>Structural Molecular Biology MRes</li>\r\n \t<li>Structural Steel Design MSc</li>\r\n \t<li>Surgical Education PG Dip</li>\r\n \t<li>Surgical Education MEd</li>\r\n \t<li>Surgical Innovation PG Cert</li>\r\n \t<li>Surgical Innovation PG Dip</li>\r\n \t<li>Surgical Innovation MSc</li>\r\n \t<li>Sustainable Energy Futures MSc</li>\r\n \t<li>Systems and Synthetic Biology MRes</li>\r\n \t<li>Taxonomy, Biodiversity and Evolution MSc</li>\r\n \t<li>Translational Neuroscience MSc</li>\r\n \t<li>Transport MSc</li>\r\n \t<li>Tropical Forest Ecology MRes</li>\r\n</ul>\r\n<a href=\"https://www.imperial.ac.uk/study/pg/courses/\">\r\nMore Info on Graduate Degrees\r\n</a>\r\n<h3>Social Media</h3>\r\n<a href=\"https://www.facebook.com/imperialcollegelondon\" target=\"_blank\" rel=\"noopener\">\r\nFacebook\r\n</a>\r\n<a href=\"https://twitter.com/imperialcollege\" target=\"_blank\" rel=\"noopener\">\r\nTwitter\r\n</a>\r\n<a href=\"https://instagram.com/imperialcollege\" target=\"_blank\" rel=\"noopener\">\r\nInstagram\r\n</a>\r\n<a href=\"https://www.youtube.com/user/imperialcollegevideo\" target=\"_blank\" rel=\"noopener\">\r\nYoutube\r\n</a>\r\n<h3>Additional University Links</h3>\r\n<ul>\r\n \t<li><a href=\"https://www.imperial.ac.uk/\" target=\"_blank\" rel=\"noopener\">\r\nHome Page\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/study/international-students/information-by-region/north-america/\" target=\"_blank\" rel=\"noopener\">\r\nUSA/International Page\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/study/fees-and-funding/undergraduate/bursaries-grants-scholarships/\" target=\"_blank\" rel=\"noopener\">\r\nInternational Tuition\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/study/fees-and-funding/undergraduate/bursaries-grants-scholarships/\" target=\"_blank\" rel=\"noopener\">\r\nScholarships\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/study/ug/fees-and-funding/loans-and-grants/us-loans/\" target=\"_blank\" rel=\"noopener\">\r\nFAFSA\r\n</a></li>\r\n</ul>\r\n<ul>\r\n \t<li><a href=\"https://www.imperial.ac.uk/study/visit/events/\" target=\"_blank\" rel=\"noopener\">\r\nVirtual Events\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/research-and-innovation/\" target=\"_blank\" rel=\"noopener\">\r\nResearch\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/students/accommodation/\" target=\"_blank\" rel=\"noopener\">\r\nHousing/Accommodation\r\n</a></li>\r\n \t<li><a href=\"https://www.imperial.ac.uk/careers\" target=\"_blank\" rel=\"noopener\">\r\nCareers Office\r\n</a></li>\r\n \t<li><a href=\"https://www.imperialcollegeunion.org/activities/a-to-z\" target=\"_blank\" rel=\"noopener\">\r\nClubs/Societies\r\n</a></li>\r\n</ul>\r\n<a href=\"https://google.https//www.imperial.ac.uk/study/pg/apply/\">\r\nAPPLY NOW\r\n</a>\r\n<h3>REQUEST MORE INFORMATION</h3>\r\n[contact-form-7 id=\"3080\" title=\"University of Lincoln\"]","post_title":"Imperial College London","post_link":"https://theukstudyexpert.com/universities/imperial-college-london/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Imperial College London\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/Untitled-design-21-e1712874673508-300x158.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"Universities","post_tags":"3.0, 3.1, 3.2, 3.3+, Business Economics, Engineering, England, Health Medicine, Life Physical Sciences, Technology Computer Science","%_custom_priority_meta_key%":"3","taxonomy=category":"Universities","taxonomy=post_tag":"3.0, 3.1, 3.2, 3.3+, Business Economics, Engineering, England, Health Medicine, Life Physical Sciences, Technology Computer Science","city_country":"London, England"},"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png"},"id":10239,"infowindow_disable":false,"categories":[{"icon":"https://theukstudyexpert.com/wp-content/uploads/2024/02/University-Map-Pin-2.png","name":"University","id":"1","type":"category","extension_fields":{"cat_order":"1"}}]},{"source":"post","title":"London Metropolitan University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"London Metropolitan University\" width=\"300\" height=\"158\" src=\"https://theukstudyexpert.com/wp-content/uploads/2023/12/London-Metropolitan-University-300x158.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n<a href=\"https://theukstudyexpert.com/universities/londonmet/\" class=\"fc-item-title fc-item-primary-text-color fc-text-center\">London Metropolitan University</a>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Based in England\u2019s historic capital city, London Metropolitan University has a rich history of education with its roots dating back to 1848 offering a wide range of courses across two London campuses. \r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>","content":"Based in England\u2019s historic capital city, London Metropolitan University has a rich history of education with its roots dating back to 1848 offering a wide range of courses across two London campuses. ","address":"166-220 Holloway Rd, London N7 8DB, UK","location":{"lat":"51.5526146","state":"England","country":"United Kingdom","lng":"-0.1113049","onclick_action":"marker","redirect_permalink":"https://theukstudyexpert.com/universities/londonmet/","zoom":5,"extra_fields":{"post_excerpt":"Based in England\u2019s historic capital city, London Metropolitan University has a rich history of education with its roots dating back to 1848 offering a wide range of courses across two London campuses. ","post_content":"<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Newsletter3.jpg\" alt=\"Newsletter+3\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Image4.jpg\" alt=\"Image+4\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Image1.jpg\" alt=\"Image+1\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Image3.jpg\" alt=\"Image+3\" /></figure>\r\n<figure><img src=\"https://theukstudyexpert.com/wp-content/uploads/2023/11/Image2.jpg\" alt=\"Image+2\" /></figure>\r\n<a href=\"#contact-form\">\r\nContact London Metropolitan University\r\n</a>\r\n\r\n<strong>Location:</strong> Tower Building, 166-220 Holloway Road, London, N7 8DB\r\n\r\n<strong>Website:</strong> <a href=\"http://www.londonmet.ac.uk/\" target=\"_blank\" rel=\"noopener\">http://londonmet.ac.uk/</a>\r\n<h3>Overview</h3>\r\nBased in England\u2019s historic capital city, London Metropolitan University has a rich history of education with its roots dating back to 1848. Taking its current form following a merger of two well-renowned universities in 2002, it offers a wide range of courses across two London campuses.\r\n\r\nThe Aldgate campus is home to the University\u2019s architecture, art and design courses, with all other subjects being taught at the Holloway campus (opposite Holloway Road tube station). This campus in north London has developed into a modern, progressive learning centre and over the last 100 years has developed a strong reputation for widening access to education for those around the world.\r\n\r\nStudents studying at London Metropolitan University will receive excellent specialised tuition, offering a wide number of high-quality courses covering various subject areas. This is underpinned by the expertise of experienced academic staff and access to world-class resources. Those studying at the university also have access to all communal spaces including libraries, cafes and eateries. There are also superb links to businesses and the six distinct schools at London Met link into various sectors and harness research opportunities for staff and students alike helping to create an engaging and diverse learning experience.\r\n\r\nLondon is an exciting and culturally diverse city with immense opportunities in terms of work, education and social life, making it a popular destination for international students. London Metropolitan University boasts an active and involved population of international students, and offers advice and assistance with accommodation, funding and careers, as well as academic and wellbeing support.\r\n\r\n<strong>Population: </strong>12,000\r\n\r\n<strong>Campus Type: </strong>Urban\r\n<h3>Quick Facts</h3>\r\n<ul>\r\n \t<li><strong>Teaching Quality:</strong> Acclaimed for its student support, ranking 9th for teaching quality and 10th for student experience (The Times and Sunday Times Good University Guide 2024), ensuring an enriching and supportive learning environment.</li>\r\n \t<li><strong>Prime London Locations:</strong> The Aldgate campus is just a 15-minute stroll from the iconic Tower Bridge, while the Holloway campus is conveniently located just two stops from the International (and magical) travel hub of Kings Cross Station, placing the best of London at your doorstep.</li>\r\n \t<li><strong>Cutting-edge Facilities:</strong> Boasts an array of state-of-the-art facilities across various disciplines, including one of the most advanced science teaching facilities in Europe; a \u00a330 million Science Centre, an innovative health simulation suite, mock courtroom, interpreting suite, TV studio, along with dedicated workshops and studio spaces for art, architecture, and design.</li>\r\n \t<li><strong>Championing Sustainability:</strong> Widely recognised for their significant contributions to environmental sustainability, London Met leads UK universities with an 80% reduction in carbon emissions since 2005-06 (People and Planet Sustainability League Table, 2021).</li>\r\n \t<li><strong>Career-focused Programs:</strong> With a 100% commitment to student success, all undergraduate programs at London Met feature work-related learning opportunities such as placements, client projects, and on-campus experiences, supported by the Accelerator business incubator and pro bono, charities and small business clinics, ensuring graduates are career-ready. London Met ranks 6th in the UK for producing CEOs and Managing Directors (Hitachi Capital Invoice Finance, 2021).</li>\r\n \t<li><strong>Commitment to Equity and Inclusion:</strong> The university's dedication to diversity and inclusion is underscored by the establishment of the Centre for Equity and Inclusion in 2020, with a \u00a315 million commitment towards advancing racial equity and inclusion.</li>\r\n \t<li style=\"list-style-type: none;\"></li>\r\n</ul>\r\n<h3>Videos</h3>\r\nhttps://www.youtube.com/watch?v=2QuKXflWChs&amp;ab_channel=LondonMetropolitanUniversityhttps://www.youtube.com/watch?v=2UAH1pLxtc0&amp;list=PLItN3B6F2de_DFyHkT460cg6vI49DMC9_&amp;index=3&amp;ab_channel=LondonMetropolitanUniversityhttps://youtu.be/miEODksicmohttps://www.youtube.com/watch?v=INT_BkJt0ekhttps://youtu.be/97Y5rc0abs4https://www.youtube.com/watch?v=d_2Xr07DGnA\r\n<h3>Undergraduate Information</h3>\r\n<h4>US Entry Requirements</h4>\r\nHigh School Diploma GPA of 2.8+, or GED 165+ in each of 4 subject areas.\r\n\r\nPLUS one of the following qualifications:\r\n<ul>\r\n \t<li>SAT 1100+</li>\r\n \t<li>ACT 25+</li>\r\n \t<li>2 Advanced Placement (AP) exam score of 3+</li>\r\n \t<li><a href=\"https://www.londonmet.ac.uk/usa-assessment-alternative/\">London Met Alternative assessment</a> for students without test scores.</li>\r\n</ul>\r\n<strong>4 Year Undergraduate Degrees</strong>\r\n\r\n<strong>\u00a0</strong>\r\n\r\nHigh School Diploma GPA of 2.0+, or GED 145+ in each of 4 subject areas.\r\n\r\nPLUS one of the following qualifications:\r\n<ul>\r\n \t<li>SAT 900+</li>\r\n \t<li>ACT 20+</li>\r\n \t<li>Two AP tests with score of 2+</li>\r\n \t<li><a href=\"https://www.londonmet.ac.uk/usa-assessment-alternative/\">London Met Alternative assessment</a> for students without test scores.</li>\r\n</ul>\r\n<strong>\u00a0</strong>\r\n\r\n<strong>Transfer Applicants:\u00a0</strong>\r\n\r\n<strong>\u00a0</strong>\r\n\r\nStudents who have completed an associate\u2019s degree at a community college or two years (60 credits) at a US university with a GPA of 2.7 in a relevant subject area may be considered for Advanced Entry to Year 2 (evaluated on a case-by-case basis).\r\n\r\n<a tabindex=\"0\">View All Undergraduate Majors</a>\r\n<ul>\r\n \t<li>Accounting and Finance (including foundation year) BA (Hons)</li>\r\n \t<li>Accounting and Finance BA</li>\r\n \t<li>Accounting and Financial Services (Top-up) BA (Hons)</li>\r\n \t<li>Advertising, Marketing Communications and Public Relations BA</li>\r\n \t<li>Airline, Airport and Aviation Management (including foundation year) BSc (Hons)</li>\r\n \t<li>Airline, Airport and Aviation Management BSc (Hons)</li>\r\n \t<li>Architect Apprenticeship (Level 7) (RI Part 2 and Part 3) BA</li>\r\n \t<li>Architecture (including foundation year) BA (Hons)</li>\r\n \t<li>Architecture (Top-Up) BA (Hons)</li>\r\n \t<li>Architecture Apprenticeship (RI 2 and 3) \u2013 MArch (RI 2), PG Cert (RI 3) BA</li>\r\n \t<li>Architecture BA</li>\r\n \t<li>Art and Design (including foundation year) BA (Hons)</li>\r\n \t<li>Banking and Finance (including foundation year) BSc (Hons)</li>\r\n \t<li>Banking and Finance BSc (Hons)</li>\r\n \t<li>Beauty Marketing and Journalism BA (Hons)</li>\r\n \t<li>Biochemistry (including foundation year) BSc (Hons)</li>\r\n \t<li>Biochemistry BSc (Hons)</li>\r\n \t<li>Biological Science (including foundation year) BSc (Hons)</li>\r\n \t<li>Biological Science BSc (Hons)</li>\r\n \t<li>Biology of Infectious Disease (including foundation year) BSc (Hons)</li>\r\n \t<li>Biomedical Science (including foundation year) BSc (Hons)</li>\r\n \t<li>Biomedical Science BSc (Hons)</li>\r\n \t<li>Business Computer Systems (top-up) BSc (Hons)</li>\r\n \t<li>Business Management (including foundation year) BA (Hons)</li>\r\n \t<li>Business Management (Top-up) BA (Hons)</li>\r\n \t<li>Business Management and Human Resource Management BA (Hons)</li>\r\n \t<li>Business Management and Marketing (including foundation year) BA (Hons)</li>\r\n \t<li>Business Management and Marketing BA</li>\r\n \t<li>Business Management BA</li>\r\n \t<li>Chemistry (including foundation year) BSc (Hons)</li>\r\n \t<li>Chemistry BSc (Hons)</li>\r\n \t<li>Community Development and Leadership (including foundation year) BSc (Hons)</li>\r\n \t<li>Community Development and Leadership BSc (Hons)</li>\r\n \t<li>Computer Networking and Cloud Security (including foundation year) BEng (Hons)</li>\r\n \t<li>Computer Networking and Cloud Security BEng (Hons)</li>\r\n \t<li>Computer Networking and Cyber Security (including foundation year) BSc (Hons)</li>\r\n \t<li>Computer Networking and Cyber Security BSc (Hons)</li>\r\n \t<li>Computer Networking and Infrastructure Security (including foundation year) BEng</li>\r\n \t<li>Computer Networking and Infrastructure Security BEng</li>\r\n \t<li>Computer Science (including foundation year) BSc (Hons)</li>\r\n \t<li>Computer Science BSc (Hons)</li>\r\n \t<li>Computer Systems Engineering and Robotics (including foundation year) BEng (Hons)</li>\r\n \t<li>Computer Systems Engineering and Robotics BEng</li>\r\n \t<li>Computing (including foundation year) BSc (Hons)</li>\r\n \t<li>Computing BSc (Hons)</li>\r\n \t<li>Construction Management BSc (Hons)</li>\r\n \t<li>Counselling and Coaching BSc (Hons)</li>\r\n \t<li>Counselling BSc (Hons)</li>\r\n \t<li>Creative Writing and English Literature (including foundation year) BA (Hons)</li>\r\n \t<li>Creative Writing and English Literature BA</li>\r\n \t<li>Criminology (including foundation year) BSc (Hons)</li>\r\n \t<li>Criminology and International Security BA</li>\r\n \t<li>Criminology and Law BA</li>\r\n \t<li>Criminology and Policing BSc (Hons)</li>\r\n \t<li>Criminology and Psychology BSc (Hons)</li>\r\n \t<li>Criminology and Sociology BSc (Hons)</li>\r\n \t<li>Criminology and Youth Studies BSc (Hons)</li>\r\n \t<li>Criminology BSc (Hons)</li>\r\n \t<li>Cyber Security and Forensic Computing (Top-up) BSc (Hons)</li>\r\n \t<li>Data Science (including foundation year) BSc (Hons)</li>\r\n \t<li>Data Science BSc (Hons)</li>\r\n \t<li>Dietetics and Nutrition BSc (Hons)</li>\r\n \t<li>Dietetics BSc (Hons)</li>\r\n \t<li>Digital Business Management BSc (Hons)</li>\r\n \t<li>Digital Forensics and Cyber Security (including foundation year) BSc (Hons)</li>\r\n \t<li>Digital Forensics and Cyber Security BSc (Hons)</li>\r\n \t<li>Digital Media (including foundation year) BA (Hons)</li>\r\n \t<li>Digital Media BA</li>\r\n \t<li>Diplomacy and International Relations BA</li>\r\n \t<li>Early Childhood Studies (including foundation year) BA (Hons)</li>\r\n \t<li>Early Childhood Studies (Top-Up) BA (Hons)</li>\r\n \t<li>Early Childhood Studies BA</li>\r\n \t<li>Economics (including foundation year) BSc (Hons)</li>\r\n \t<li>Economics and Finance BSc (Hons)</li>\r\n \t<li>Economics BSc (Hons)</li>\r\n \t<li>Economics, Finance and International Business BSc (Hons)</li>\r\n \t<li>Education (including foundation year) BA (Hons)</li>\r\n \t<li>Education BA (Hons)</li>\r\n \t<li>Education Studies and English Literature BA</li>\r\n \t<li>Education Studies BA</li>\r\n \t<li>Electronic Engineering and Internet of Things (including foundation year) BEng (Hons)</li>\r\n \t<li>Electronic Engineering and Internet of Things BEng (Hons)</li>\r\n \t<li>Electronics and Internet of Things (including foundation year) BEng (Hons)</li>\r\n \t<li>Electronics and Internet of Things BEng (Hons)</li>\r\n \t<li>English Literature BA</li>\r\n \t<li>Events Management (including foundation year) BA (Hons)</li>\r\n \t<li>Events Management and Marketing BA (Hons)</li>\r\n \t<li>Events Management BA</li>\r\n \t<li>Examination in Professional Practice in Architecture (RI 3) BA</li>\r\n \t<li>Fashion (including foundation year) BA (Hons)</li>\r\n \t<li>Fashion (Top-Up) BA (Hons)</li>\r\n \t<li>Fashion Accessories and Jewellery BA</li>\r\n \t<li>Fashion BA</li>\r\n \t<li>Fashion Marketing and Business Management BA</li>\r\n \t<li>Fashion Marketing and Journalism (including foundation year) BA (Hons)</li>\r\n \t<li>Fashion Marketing and Journalism BA (Hons)</li>\r\n \t<li>Fashion Photography (including foundation year) BA (Hons)</li>\r\n \t<li>Fashion Photography BA</li>\r\n \t<li>Fashion Textiles (including foundation year) BA (Hons)</li>\r\n \t<li>Fashion Textiles BA (Hons)</li>\r\n \t<li>Film and Television Production (including foundation year) BA (Hons)</li>\r\n \t<li>Film and Television Production BA</li>\r\n \t<li>Film and Television Studies (including foundation year) BA (Hons)</li>\r\n \t<li>Film and Television Studies BA</li>\r\n \t<li>Fine Art (including foundation year) BA (Hons)</li>\r\n \t<li>Fine Art (Top-up) BA (Hons)</li>\r\n \t<li>Fine Art BA</li>\r\n \t<li>Forensic Science (including foundation year) BSc (Hons)</li>\r\n \t<li>Furniture and Product Design (including foundation year) BA (Hons)</li>\r\n \t<li>Furniture and Product Design BA</li>\r\n \t<li>Games Animation, Modelling and Effects (including foundation year) BSc (Hons)</li>\r\n \t<li>Games Animation, Modelling and Effects BSc (Hons)</li>\r\n \t<li>Games Programming (including foundation year) BSc (Hons)</li>\r\n \t<li>Games Programming BSc (Hons)</li>\r\n \t<li>Graphic Design (including foundation year) BA (Hons)</li>\r\n \t<li>Graphic Design (with preparatory semester) BA (Hons)</li>\r\n \t<li>Graphic Design BA</li>\r\n \t<li>Health and Social Care (including foundation year) BSc (Hons)</li>\r\n \t<li>Health and Social Care (Top-up) BSc (Hons)</li>\r\n \t<li>Health and Social Care BSc (Hons)</li>\r\n \t<li>Herbal Medicinal Science (Top-Up) BSc (Hons)</li>\r\n \t<li>Human Nutrition (including foundation year) BSc (Hons)</li>\r\n \t<li>Human Nutrition BSc (Hons)</li>\r\n \t<li>Illustration and Animation (including foundation year) BA (Hons)</li>\r\n \t<li>Illustration and Animation (with preparatory semester) BA (Hons)</li>\r\n \t<li>Illustration and Animation BA</li>\r\n \t<li>Interior Architecture and Design (including foundation year) BA (Hons)</li>\r\n \t<li>Interior Architecture and Design

Take Our Find Your UK University Quiz

Undergraduate Universities

Search Undergraduate Universities

London Metropolitan University

Take Our

Find Your UK University

Quiz